Multiple dependencies of same "type" about component HOT 1 CLOSED

(ns teller.component-test
  (:require [clojure.test :refer [deftest is]]
            [com.stuartsierra.component :as component]
            [taoensso.timbre :as log]))

(defprotocol MappableHandler
  (get-label [this])
  (get-handler-fn [this]))

(defrecord Handler [db label handler]
  component/Lifecycle
  (start [this]
    this)
  (stop [this]
    this)

  MappableHandler
  (get-label [_this]
    label)
  (get-handler-fn [_this]
    handler))

(defrecord Mapper [db handler-labels]
  component/Lifecycle
  (start [this]
      ; get the injected handlers
    (let [handlers (into {}
                         (map (fn [label]
                                (let [component (get this label)
                                      handler-label (get-label component)
                                      handler-fn (get-handler-fn component)]
                                  [handler-label handler-fn])))
                         handler-labels)]
      (log/info "handlers" handlers)
      (assoc this :handlers handlers)))
  (stop [this]
    (assoc this :handlers nil)))

(defn create-system []
  (component/system-map
   :a (component/using (->Handler nil :handler-a (fn [_x] "a"))
                       [:db])
   :b (component/using (->Handler nil :handler-b (fn [_x] "b"))
                       [:db])
   :db {:conn "Database"}))

(defn add-mapper [system]
  (log/info "add-mapper")
  (let [handler-labels (into []
                             (comp (filter (fn [[_label component]]
                                             (log/info "component" component)
                                             (satisfies? MappableHandler component)))
                                   (map (fn [[label _component]]
                                          label)))
                             system)
        dep-comps (into [:db] handler-labels)]
    (log/info "after")
    (assoc system :mapper (component/using (->Mapper nil handler-labels)
                                           dep-comps))))

(defn start []
  (component/start (add-mapper (create-system))))

(deftest should-start
  (let [system (start)]
    (is (= [:handler-a :handler-b]
           (-> system
               (get-in [:mapper :handlers])
               keys)))))