wip: Add tests for record

test/cljam/io/cram/decode/record_test.clj

@@ -0,0 +1,86 @@
+(ns cljam.io.cram.decode.record-test
+  (:require [cljam.io.cram.decode.record :as record]
+            [cljam.io.cram.seq-resolver.protocol :as resolver]
+            [cljam.io.sequence :as cseq]
+            [cljam.test-common :as common]
+            [clojure.test :refer [deftest is]]))
+
+(require '[postmortem.core :as pm])
+(defn- build-stub-decoders [data]
+  (into {}
+        (map (fn [[k xs]]
+               (let [xs' (volatile! xs)
+                     f (fn []
+                         (let [v (first @xs')]
+                           (vswap! xs' next)
+                           v))]
+                 [k (fn [] (pm/spy>> k (f)))])))
+        data))
+
+(defn- build-stub-tag-decoders [data]
+  (into {} (map (fn [[k v]] [k (build-stub-decoders v)])) data))
+
+(deftest build-cram-record-decoder-test
+  (let [seqs (with-open [r (cseq/reader common/test-fa-file)]
+               (into {} (map (juxt :name :sequence)) (cseq/read-all-sequences r)))
+        seq-resolver (reify
+                       resolver/ISeqResolver
+                       (resolve-sequence [_ {:keys [chr start end]}]
+                         (let [s (get seqs chr)]
+                           (subs s (dec (long start)) end))))
+        cram-header {:SQ
+                     [{:SN "ref"}
+                      {:SN "ref2"}]}
+        compression-header {:preservation-map
+                            {:RN true
+                             :AP true
+                             :RR true
+                             :SM {\A {0 \C, 1 \G, 2 \T, 3 \N}
+                                  \C {0 \A, 1 \G, 2 \T, 3 \N}
+                                  \G {0 \A, 1 \C, 2 \T, 3 \N}
+                                  \T {0 \A, 1 \C, 2 \G, 3 \N}
+                                  \N {0 \A, 1 \C, 2 \G, 3 \T}}
+                             :TD [[]
+                                  [{:tag :MD, :type \Z}
+                                   {:tag :NM, :type \c}]]}}
+        slice-header {:ref-seq-id 0
+                      :start 0}
+        ds-decoders (build-stub-decoders
+                     {:BF [177 97 145]
+                      :CF [3 3 3]
+                      :RI [0 0 0]
+                      :RL [10 10 10]
+                      :AP [1 2 3]
+                      :RG [-1 -1 -1]
+                      :RN (->> ["q001" "q002" "q003"]
+                               (map #(.getBytes ^String %)))
+                      :MF [1 0 0]
+                      :NF []
+                      :NS [0 0 0]
+                      :NP [151 152 153]
+                      :TS [50 50 50]
+                      :TL [0 0 0]
+                      :FN [0 0 0]
+                      :FC []
+                      :FP []
+                      :QS (->> ["HFHHHHEHHH"
+                                "HHFHFHHHHD"
+                                "EBBFFEGEEE"]
+                               (mapcat #(.getBytes ^String %))
+                               (map #(- % 33)))
+                      :MQ [60 0 60]})
+        tag-decoders (build-stub-tag-decoders
+                      {:MD {\Z []}
+                       :NM {\c []}})
+        decoder (record/build-cram-record-decoder seq-resolver
+                                                  cram-header
+                                                  compression-header
+                                                  slice-header
+                                                  ds-decoders
+                                                  tag-decoders)]
+    (is (= {:qname "q001", :flag 177, :rname "ref", :pos 1, :mapq 60, :cigar "10M"
+            :rnext "=", :pnext 151, :tlen 50, :seq "AGCATGTTAG", :qual "HFHHHHEHHH"
+            :options [], ::record/flag 3, ::record/len 10, :end 10}
+           (decoder)))
+    #_(is (= nil (decoder)))
+    #_(is (= nil (decoder)))))