Add test for available-metrics and available-segments (#37767)

Part of #37173.

src/metabase/lib/metric.cljc

@@ -97,18 +97,19 @@
    (available-metrics query -1))
   ([query :- ::lib.schema/query
     stage-number :- :int]
-   (when-let [source-table-id (lib.util/source-table-id query)]
-     (let [metrics (lib.metadata.protocols/metrics (lib.metadata/->metadata-provider query) source-table-id)
-           metric-aggregations (into {}
-                                     (keep-indexed (fn [index aggregation-clause]
-                                                     (when (lib.util/clause-of-type? aggregation-clause :metric)
-                                                       [(get aggregation-clause 2) index])))
-                                     (:aggregation (lib.util/query-stage query stage-number)))]
-       (cond
-         (empty? metrics)             nil
-         (empty? metric-aggregations) (vec metrics)
-         :else                        (mapv (fn [metric-metadata]
-                                              (let [aggregation-pos (-> metric-metadata :id metric-aggregations)]
-                                                (cond-> metric-metadata
-                                                  aggregation-pos (assoc :aggregation-position aggregation-pos))))
-                                            metrics))))))
+   (when (zero? (lib.util/canonical-stage-index query stage-number))
+     (when-let [source-table-id (lib.util/source-table-id query)]
+      (let [metrics (lib.metadata.protocols/metrics (lib.metadata/->metadata-provider query) source-table-id)
+            metric-aggregations (into {}
+                                      (keep-indexed (fn [index aggregation-clause]
+                                                      (when (lib.util/clause-of-type? aggregation-clause :metric)
+                                                        [(get aggregation-clause 2) index])))
+                                      (:aggregation (lib.util/query-stage query stage-number)))]
+        (cond
+          (empty? metrics)             nil
+          (empty? metric-aggregations) (vec metrics)
+          :else                        (mapv (fn [metric-metadata]
+                                               (let [aggregation-pos (-> metric-metadata :id metric-aggregations)]
+                                                 (cond-> metric-metadata
+                                                   aggregation-pos (assoc :aggregation-position aggregation-pos))))
+                                             metrics)))))))

test/metabase/lib/metric_test.cljc

@@ -16,14 +16,18 @@
    :aggregation  [[:sum [:field (meta/id :venues :price) nil]]]
    :filter       [:= [:field (meta/id :venues :price) nil] 4]})
 
+(def ^:private metrics-db
+  {:metrics [{:id          metric-id
+              :name        "Sum of Cans"
+              :table-id    (meta/id :venues)
+              :definition  metric-definition
+              :description "Number of toucans plus number of pelicans"}]})
+
 (def ^:private metadata-provider
-  (lib.tu/mock-metadata-provider
-   meta/metadata-provider
-   {:metrics [{:id          metric-id
-               :name        "Sum of Cans"
-               :table-id    (meta/id :venues)
-               :definition  metric-definition
-               :description "Number of toucans plus number of pelicans"}]}))
+  (lib.tu/mock-metadata-provider meta/metadata-provider metrics-db))
+
+(def ^:private metadata-provider-with-cards
+  (lib.tu/mock-metadata-provider lib.tu/metadata-provider-with-mock-cards metrics-db))
 
 (def ^:private metric-clause
   [:metric {:lib/uuid (str (random-uuid))} metric-id])
@@ -119,7 +123,22 @@
                   (map #(lib/display-info query-with-metric %)
                        metrics)))))))
   (testing "query with different Table -- don't return Metrics"
-    (is (nil? (lib/available-metrics (lib/query metadata-provider (meta/table-metadata :orders)))))))
+    (is (nil? (lib/available-metrics (lib/query metadata-provider (meta/table-metadata :orders))))))
+  (testing "for subsequent stages -- don't return Metrics (#37173)"
+    (let [query (lib/append-stage (lib/query metadata-provider (meta/table-metadata :venues)))]
+      (is (nil? (lib/available-metrics query)))
+      (are [stage-number] (nil? (lib/available-metrics query stage-number))
+        1 -1)))
+  (testing "query with different source table joining the metrics table -- don't return Metrics"
+    (let [query (-> (lib/query metadata-provider (meta/table-metadata :categories))
+                    (lib/join (-> (lib/join-clause (lib/query metadata-provider (meta/table-metadata :venues))
+                                                   [(lib/= (meta/field-metadata :venues :price) 4)])
+                                  (lib/with-join-fields :all))))]
+      (is (nil? (lib/available-metrics query)))))
+  (testing "query based on a card -- don't return Metrics"
+    (doseq [card-key [:venues :venues/native]]
+      (let [query (lib/query metadata-provider-with-cards (card-key lib.tu/mock-cards))]
+        (is (nil? (lib/available-metrics (lib/append-stage query))))))))
 
 (deftest ^:parallel aggregate-with-metric-test
   (testing "Should be able to pass a Metric metadata to `aggregate`"

test/metabase/lib/segment_test.cljc

@@ -19,14 +19,18 @@
                   [:> [:field (meta/id :venues :id) nil] [:* [:field (meta/id :venues :price) nil] 11]]
                   [:contains [:field (meta/id :venues :name) nil] "BBQ" {:case-sensitive true}]]})
 
+(def ^:private segments-db
+  {:segments [{:id          segment-id
+               :name        "PriceID-BBQ"
+               :table-id    (meta/id :venues)
+               :definition  segment-definition
+               :description "The ID is greater than 11 times the price and the name contains \"BBQ\"."}]})
+
 (def ^:private metadata-provider
-  (lib.tu/mock-metadata-provider
-   meta/metadata-provider
-   {:segments [{:id          segment-id
-                :name        "PriceID-BBQ"
-                :table-id    (meta/id :venues)
-                :definition  segment-definition
-                :description "The ID is greater than 11 times the price and the name contains \"BBQ\"."}]}))
+  (lib.tu/mock-metadata-provider meta/metadata-provider segments-db))
+
+(def ^:private metadata-provider-with-cards
+  (lib.tu/mock-metadata-provider lib.tu/metadata-provider-with-mock-cards segments-db))
 
 (def ^:private segment-clause
   [:segment {:lib/uuid (str (random-uuid))} segment-id])
@@ -97,7 +101,17 @@
                  (lib/available-segments multi-stage-query 0)
                  (lib/available-segments multi-stage-query -2)))))))
   (testing "query with different Table -- don't return Segments"
-    (is (nil? (lib/available-segments (lib/query metadata-provider (meta/table-metadata :orders)))))))
+    (is (nil? (lib/available-segments (lib/query metadata-provider (meta/table-metadata :orders))))))
+  (testing "query with different source table joining the segments table -- don't return Segments"
+    (let [query (-> (lib/query metadata-provider (meta/table-metadata :categories))
+                    (lib/join (-> (lib/join-clause (lib/query metadata-provider (meta/table-metadata :venues))
+                                                   [(lib/= (meta/field-metadata :venues :price) 4)])
+                                  (lib/with-join-fields :all))))]
+      (is (nil? (lib/available-segments query)))))
+  (testing "query based on a card -- don't return Segments"
+    (doseq [card-key [:venues :venues/native]]
+      (let [query (lib/query metadata-provider-with-cards (card-key lib.tu/mock-cards))]
+        (is (nil? (lib/available-segments (lib/append-stage query))))))))
 
 (deftest ^:parallel filter-with-segment-test
   (testing "Should be able to pass a Segment metadata to `filter`"