Create Random instances of Metabase models

create_random.clj

(ns metabase.test.generate
  "Facilities for generating random instances of our various models."
  (:require [metabase.models :refer [Card Dashboard DashboardCard]]
            [metabase.test :as mt]
            [methodical.core :as m]
            [toucan.db :as db]
            [toucan.util.test :as tt]))

(m/defmulti create-random!*
  {:arglists '([model property-overrides])}
  (fn [model _]
    (class model)))

(m/defmethod create-random!* :default
  [model property-overrides]
  (let [properties (merge (tt/with-temp-defaults model)
                          property-overrides)]
    (db/insert! model properties)))

(defn- coin-toss? []
  (zero? (rand-int 2)))

(defn- random-query []
  ;; TODO -- something more random
  (cond-> (mt/mbql-query venues)
    ;; 50% chance to add an aggregation
    (coin-toss?) (assoc-in [:query :aggregation] [[:count]])
    ;; 50% chance to add a filter on `price`
    (coin-toss?) (assoc-in [:query :filter] [:=
                                             [:field-id (mt/id :venues :price)]
                                             (inc (rand-int 4))])))

(m/defmethod create-random!* :before (class Card)
  [_ property-overrides]
  (merge {:dataset_query (random-query)}
         property-overrides))

(m/defmethod create-random!* :after (class Dashboard)
  [_ dashboard]
  ;; create 0-4 Cards and add to a Dashboard when creating a Dashboard
  (dotimes [_ (rand-int 5)]
    (let [card (create-random!* Card nil)]
      (println "Creating random Card with query" (pr-str (:dataset_query card)))
      (create-random!* DashboardCard {:dashboard_id (:id dashboard), :card_id (:id card)})))
  dashboard)

(defn create-random!
  {:arglists '([model] [n model] [model property-overrides] [n model property-overrides])}
  ([model]
   (create-random!* model nil))
  ([x y]
   (if (integer? x)
     (create-random! x y nil)
     (create-random!* x y)))
  ([n model property-overrides]
   (vec (for [_ (range n)]
          (create-random!* model property-overrides)))))

(defn x []
  (mt/with-model-cleanup [Card Dashboard]
    ;; create a random Dashboard.
    (let [dash (create-random! Dashboard)]
      (println "CREATED" (db/count DashboardCard :dashboard_id (:id dash)) "CARDS")
      dash)))