Issue/54/record io tests

dev-resources/src/meson/debug.clj → dev-resources/src/meson/dev.clj

@@ -1,4 +1,4 @@
-(ns meson.debug
+(ns meson.dev
   (:require [clojure.core.async :as async :refer [<! >!]]
             [clojure.java.io :as io]
             [clojure.pprint :refer [print-table]]

project.clj

@@ -4,25 +4,14 @@
   :license {:name "Apache License, Version 2.0"
             :url "http://www.apache.org/licenses/LICENSE-2.0"}
   :dependencies [[org.clojure/clojure "1.8.0"]
-                 [org.clojure/core.async "0.2.391"]
+                 [org.clojure/core.async "0.2.395"]
                  [org.clojure/data.codec "0.1.0"]
                  [org.clojure/data.json "0.2.6"]
                  [org.apache.mesos/mesos "1.0.1"]
                  [clj-http "3.3.0"]
                  [clojusc/twig "0.2.6"]
                  [leiningen-core "2.7.1"]
                  [potemkin "0.4.3"]]
-  :plugins [[lein-codox "0.10.0"]]
-  :codox {
-    :project {
-      :name "meson"
-      :description "Clojure Client Library for the Mesos HTTP API"}
-    :namespaces [#"^meson\.(?!debug)"]
-    :output-path "docs/master/current"
-    :doc-paths ["docs/source"]
-    :metadata {
-      :doc/format :markdown
-      :doc "Documentation forthcoming"}}
   :profiles {
     :uber {
       :aot :all}
@@ -40,7 +29,19 @@
         :integration :integration}}
     :dev {
       :source-paths ["dev-resources/src"]
-      :repl-options {:init-ns meson.debug}
+      :repl-options {:init-ns meson.dev}
       :dependencies [
         [org.clojure/tools.namespace "0.2.11"
-         :exclusions [org.clojure/clojure]]]}})
+         :exclusions [org.clojure/clojure]]]}
+    :docs {
+      :plugins [[lein-codox "0.10.1"]]
+      :codox {
+        :project {
+          :name "meson"
+          :description "Clojure Client Library for the Mesos HTTP API"}
+        :namespaces [#"^meson\.(?!dev)"]
+        :output-path "docs/master/current"
+        :doc-paths ["docs/source"]
+        :metadata {
+          :doc/format :markdown
+          :doc "Documentation forthcoming"}}}})

src/meson/client.clj

@@ -30,10 +30,10 @@
      ;:accept "application/json"
      :content-type "application/x-protobuf" ; or application/x-protobuf
      :accept "application/x-protobuf"
-     :debug true
-     :debug-body true
-     :throw-entire-message? true
-     :log-level :info
+     :debug false
+     :debug-body false
+     :throw-entire-message? false
+     :log-level :error
      :headers {:user-agent user-agent}
      :client-params {
        "http.useragent" user-agent}}})

src/meson/client/impl/master/scheduler.clj

@@ -3,19 +3,16 @@
             [clojure.data.json :as json]
             [clojure.string :as string]
             [clojure.tools.logging :as log]
-            [meson.http :as http]))
+            [meson.http :as http]
+            [meson.util :as util])
+  (:import [clojure.lang Keyword]))
 
-(defn convert-upper
-  [type]
-  (-> type
-      (name)
-      (string/upper-case)))
-
-(defn convert-lower
-  [type]
-  (-> type
-      (name)
-      (string/lower-case)))
+(def scheduler-path "api/v1/scheduler")
+(def default-scheduler-timeout 10)
+(def default-scheduler-threads 4)
+(def default-scheduler-opts
+  {:timeout default-scheduler-timeout
+   :threads default-scheduler-threads})
 
 (defn start
   ""
@@ -24,7 +21,7 @@
   ([this opts]
     (log/debug "Starting connection manager for the scheduler ...")
     (->> opts
-         (into {:timeout 10 :threads 4})
+         (into default-scheduler-opts)
          (http-conn-mgr/make-reusable-conn-manager)
          (assoc this :conn-mgr))))
 
@@ -35,18 +32,18 @@
   (http-conn-mgr/shutdown-manager (:conn-mgr this)))
 
 (defn call
-  ([this type]
+  ([this ^Keyword type]
     (call this type nil))
-  ([this type payload]
-    (call this type payload "application/json")) ; put in a const
-  ([this type payload content-type]
+  ([this ^Keyword type payload]
+    (call this type payload http/json-content-type))
+  ([this ^Keyword type payload content-type]
     (call this type payload content-type {}))
-  ([this type payload content-type opts]
-    (let [data {:type (convert-upper type)
-                (convert-lower type) payload}]
+  ([this ^Keyword type payload content-type opts]
+    (let [data {:type (util/convert-upper type)
+                (util/convert-lower type) payload}]
       (http/post
         this
-        "api/v1/scheduler"
+        scheduler-path
         :body (json/write-str data)
         :opts (into opts {:content-type content-type
                           :accept content-type})))))

src/meson/http.clj

@@ -8,12 +8,15 @@
             [meson.util :as util])
   (:refer-clojure :exclude [get]))
 
+(def json-content-type "application/json")
+(def protobuf-content-type "application/x-protobuf")
+
 (defn convert-data
   ""
   [content-type record-name body]
   (case content-type
-    "application/json" (pb-mesos/map->json record-name body)
-    "application/x-protobuf" (pb-mesos/->map record-name body)))
+    json-content-type (pb-mesos/map->json record-name body)
+    protobuf-content-type (pb-mesos/->map record-name body)))
 
 (defn merge-options
   ""

src/meson/util.clj

@@ -1,7 +1,9 @@
 (ns meson.util
   "Some convenience/utility functions used in the rest of Mesomatic."
   (:require [clojure.data.json :as json]
-            [clojure.string :as string]))
+            [clojure.java.io :as io]
+            [clojure.string :as string])
+  (:import [clojure.lang Keyword]))
 
 (defn camel->under
   "From Emerick, Grande, Carper 2012 p.70."
@@ -25,6 +27,18 @@
           (when (odd? (count clauses))
             (list (last clauses)))))))
 
+(defn convert-upper
+  [^Keyword type]
+  (-> type
+      (name)
+      (string/upper-case)))
+
+(defn convert-lower
+  [^Keyword type]
+  (-> type
+      (name)
+      (string/lower-case)))
+
 (defn newline?
   ""
   [byte]
@@ -58,3 +72,13 @@
       (bytes->str)
       (json/read-str :key-fn keyword)
       (update :type #(keyword (string/lower-case %)))))
+
+(defn str->bytes
+  ""
+  [str]
+  (.getBytes str))
+
+(defn str->stream
+  ""
+  [str]
+  (io/input-stream (str->bytes str)))

test/meson/client/agent_test.clj

@@ -10,7 +10,7 @@
   (let [c (agent/create)]
     (is (= (:base-path c) "/"))
     (is (= (:version c) "1"))
-    (is (= (get-in c [:options :debug]) true))))
+    (is (= (get-in c [:options :debug]) false))))
 
 ;;; Integration Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

test/meson/client/master/scheduler_test.clj

@@ -15,7 +15,7 @@
     (is (= (:master c) "localhost:5050"))
     (is (= (:host c) "localhost"))
     (is (= (:port c) "5050"))
-    (is (= (get-in c [:options :debug]) true))))
+    (is (= (get-in c [:options :debug]) false))))
 
 (deftest ^:unit get-context
   (let [c (scheduler/->client)]

test/meson/client/master_test.clj

@@ -10,7 +10,7 @@
   (let [c (master/create)]
     (is (= (:base-path c) "/"))
     (is (= (:version c) "1"))
-    (is (= (get-in c [:options :debug]) true))))
+    (is (= (get-in c [:options :debug]) false))))
 
 ;;; Integration Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -22,7 +22,7 @@
 (deftest ^:integration get-metrics
   (let [c (master/create testing-master)
         metrics-keys (sort (keys (master/get-metrics c)))]
-    (is (= (count metrics-keys) 126))
+    (is (> (count metrics-keys) 100))
     (is (= (first metrics-keys) :allocator/event_queue_dispatches))
     (is (= (second metrics-keys) :allocator/mesos/allocation_run_ms))
     (is (= (last metrics-keys) :system/mem_total_bytes))))

test/meson/client_test.clj

@@ -16,7 +16,7 @@
   (let [c (client/->base-client)]
     (is (= (:base-path c) "/"))
     (is (= (:version c) "1"))
-    (is (= (get-in c [:options :debug]) true))))
+    (is (= (get-in c [:options :debug]) false))))
 
 (deftest ^:unit get-context
   (let [c (client/->base-client)]

test/meson/testing/payloads.clj

@@ -0,0 +1,27 @@
+(ns meson.testing.payloads
+  (:require [meson.util :as util]))
+
+(defn subscribe
+  []
+  (-> (str "139\n"
+           "{\"type\":\"SUBSCRIBE\","
+           "\"subscribe\":{\"framework_info\":{"
+                               "\"user\":\"Alice\","
+                               "\"name\":\"Test Clojure\\/HTTP Framework (Clojure)\","
+                               "\"hostname\":\"127.0.0.1\"}}}")
+      (util/str->stream)))
+
+(defn subscribed
+  []
+  (-> (str "139\n"
+           "{\"type\":\"SUBSCRIBED\","
+           "\"subscribed\":{\"framework_id\":{"
+                                "\"value\":\"5f1bf690-0145-44be-96ae-145e5c51fccc-0017\"},"
+                           "\"heartbeat_interval_seconds\":15.0}}")
+      (util/str->stream)))
+
+(defn heartbeat
+  []
+  (-> (str "20\n"
+           "{\"type\":\"HEARTBEAT\"}")
+      (util/str->stream)))

test/meson/util/recordio_test.clj

@@ -0,0 +1,60 @@
+(ns meson.util.recordio-test
+  (:require [clojure.test :refer :all]
+            [meson.client.master :as master]
+            [meson.testing.payloads :as payload]
+            [meson.util :as util]
+            [meson.util.recordio :as recordio]))
+
+(def testing-host "127.0.0.1")
+(def testing-master {:master (format "%s:5050" testing-host)})
+(def framework-info
+  {:framework_info
+    {:user "Alice"
+     :name "Test Clojure/HTTP Framework (Clojure)"
+     :hostname testing-host}})
+
+;;; Unit Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ^:unit get-size
+  (is (= (recordio/get-size! (payload/subscribed)) 139)))
+
+(deftest ^:unit get-data
+  (let [stream (payload/subscribed)
+        record-size (recordio/get-size! stream)
+        bytes (recordio/get-data! stream record-size)
+        json (util/bytes->json bytes)]
+    (is (= (:type json) :subscribed))
+    (is (= (get-in json [:subscribed :framework_id :value])
+           "5f1bf690-0145-44be-96ae-145e5c51fccc-0017"))))
+
+(deftest ^:unit next
+  (let [bytes (recordio/next! (payload/subscribed))
+        json (util/bytes->json bytes)]
+    (is (= (:type json) :subscribed))
+    (is (= (get-in json [:subscribed :framework_id :value])
+           "5f1bf690-0145-44be-96ae-145e5c51fccc-0017"))))
+
+;;; Integration Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(deftest ^:integration recordio-methods
+  (testing "get-size! and get-data! ..."
+    (let [c (master/create testing-master)
+          response (master/subscribe c framework-info)
+          stream (:body response)
+          record-size (recordio/get-size! stream)
+          bytes (recordio/get-data! stream record-size)
+          json (util/bytes->json bytes)]
+      (is (= record-size 139))
+      (is (= (:type json) :subscribed))
+      (is (= (get-in json [:subscribed :heartbeat_interval_seconds]) 15.0))))
+  (testing "just next! ..."
+    (let [c (master/create testing-master)
+          response (master/subscribe c framework-info)
+          bytes (recordio/next! (:body response))
+          json (util/bytes->json bytes)]
+      (is (= (:type json) :subscribed))
+      (is (= (get-in json [:subscribed :heartbeat_interval_seconds]) 15.0)))))
+
+;;; System Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; TBD

test/meson/util_test.clj

@@ -10,6 +10,14 @@
   (is (= (util/camel->under :MyCamel) "my_camel"))
   (is (= (util/camel->under :MyCrazyCamel) "my_crazy_camel")))
 
+(deftest ^:unit str->bytes
+  (is (= (type (util/str->bytes "a string"))
+         (type (byte-array 0)))))
+
+(deftest ^:unit str->stream
+  (is (= (type (util/str->stream "a string"))
+         java.io.BufferedInputStream)))
+
 ;;; Integration Tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; TBD