test refactor: group all integration tests (#56)

All integration share same test fixture setup, so it makes sense to have
them together.

No need for ^integration metadata on tests any more, they are grouped by
namespace now.

Author: lread

test/clj_http/lite/client_test.clj

@@ -1,59 +1,9 @@
 (ns clj-http.lite.client-test
   (:require [clj-http.lite.client :as client]
-            [clj-http.lite.core-test :refer [base-req with-server current-port]]
             [clj-http.lite.util :as util]
-            [clojure.test :refer [deftest is testing use-fixtures]])
+            [clojure.test :refer [deftest is testing]])
   (:import (java.net UnknownHostException)))
 
-(use-fixtures :each with-server)
-
-(deftest ^{:integration true} roundtrip
-  ;; roundtrip with scheme as a keyword
-  (let [resp (client/request (merge (base-req) {:uri "/get" :method :get}))]
-    (is (= 200 (:status resp)))
-    (is (= "get" (:body resp))))
-  ;; roundtrip with scheme as a string
-  (let [resp (client/request (merge (base-req) {:uri    "/get"
-                                                :method :get
-                                                :scheme "http"}))]
-    (is (= 200 (:status resp)))
-    (is (= "get" (:body resp)))))
-
-(deftest ^{:integration true} basic-auth-no-creds
-  (let [resp (client/request (merge (base-req) {:method :get
-                                                :uri "/basic-auth"
-                                                :throw-exceptions false}))]
-    (is (= 401 (:status resp)))
-    (is (= "denied" (:body resp)))))
-
-(deftest ^{:integration true} basic-auth-bad-creds
-  (let [resp (client/request (merge (base-req) {:method :get
-                                                :uri "/basic-auth"
-                                                :throw-exceptions false
-                                                :basic-auth "username:nope"}))]
-    (is (= 401 (:status resp)))
-    (is (= "denied" (:body resp)))))
-
-(deftest ^{:integration true} basic-auth-creds-as-basic-auth
-  (let [resp (client/request (merge (base-req) {:method :get
-                                                :uri "/basic-auth"
-                                                :basic-auth "username:password"}))]
-    (is (= 200 (:status resp)))
-    (is (= "welcome" (:body resp)))))
-
-(deftest ^{:integration true} basic-auth-creds-as-user-info
-  (let [resp (client/request (merge (base-req) {:method :get
-                                                :uri "/basic-auth"
-                                                :user-info "username:password"}))]
-    (is (= 200 (:status resp)))
-    (is (= "welcome" (:body resp)))))
-
-(deftest ^{:integration true} basic-auth-creds-from-url
-  (let [resp (client/request {:method :get
-                              :url (format "http://username:password@localhost:%d/basic-auth" (current-port))})]
-    (is (= 200 (:status resp)))
-    (is (= "welcome" (:body resp)))))
-
 (defn is-passed [middleware req]
   (let [client (middleware identity)]
     (is (= req (client req)))))

test/clj_http/lite/core_test.clj renamed to test/clj_http/lite/integration_test.clj

@@ -1,5 +1,6 @@
-(ns clj-http.lite.core-test
-  (:require [clj-http.lite.core :as core]
+(ns clj-http.lite.integration-test
+  (:require [clj-http.lite.client :as client]
+            [clj-http.lite.core :as core]
             [clj-http.lite.util :as util]
             [clojure.test :refer [deftest is use-fixtures]]
             [clojure.string :as str]
@@ -91,55 +92,58 @@
 (defn slurp-body [req]
   (slurp (:body req)))
 
-(deftest ^{:integration true} makes-get-request
+;;
+;; Lower level internal unwrapped core requests
+;;
+(deftest makes-get-request
   (let [resp (request {:request-method :get :uri "/get"})]
     (is (= 200 (:status resp)))
     (is (= "get" (slurp-body resp)))))
 
-(deftest ^{:integration true} makes-head-request
+(deftest makes-head-request
   (let [resp (request {:request-method :head :uri "/head"})]
     (is (= 200 (:status resp)))
     (is (nil? (:body resp)))))
 
-(deftest ^{:integration true} sets-content-type-with-charset
+(deftest sets-content-type-with-charset
   (let [resp (request {:request-method :get         :uri                "/content-type"
                        :content-type   "text/plain" :character-encoding "UTF-8"})]
     (is (= "text/plain; charset=UTF-8" (slurp-body resp)))))
 
-(deftest ^{:integration true} sets-content-type-without-charset
+(deftest sets-content-type-without-charset
   (let [resp (request {:request-method :get :uri "/content-type"
                        :content-type   "text/plain"})]
     (is (= "text/plain" (slurp-body resp)))))
 
-(deftest ^{:integration true} sets-arbitrary-headers
+(deftest sets-arbitrary-headers
   (let [resp (request {:request-method :get :uri "/header"
                        :headers        {"X-My-Header" "header-val"}})]
     (is (= "header-val" (slurp-body resp)))))
 
-(deftest ^{:integration true} sends-and-returns-byte-array-body
+(deftest sends-and-returns-byte-array-body
   (let [resp (request {:request-method :post :uri "/post"
                        :body           (util/utf8-bytes "contents")})]
     (is (= 200 (:status resp)))
     (is (= "contents" (slurp-body resp)))))
 
-(deftest ^{:integration true} returns-arbitrary-headers
+(deftest returns-arbitrary-headers
   (let [resp (request {:request-method :get :uri "/get"})]
     (is (string? (get-in resp [:headers "date"])))))
 
-(deftest ^{:integration true} returns-status-on-exceptional-responses
+(deftest returns-status-on-exceptional-responses
   (let [resp (request {:request-method :get :uri "/error"})]
     (is (= 500 (:status resp)))))
 
-(deftest ^{:integration true} returns-status-on-redirect
+(deftest returns-status-on-redirect
   (let [resp (request {:request-method :get :uri "/redirect" :follow-redirects false})]
     (is (= 302 (:status resp)))))
 
-(deftest ^{:integration true} auto-follows-on-redirect
+(deftest auto-follows-on-redirect
   (let [resp (request {:request-method :get :uri "/redirect"})]
     (is (= 200 (:status resp)))
     (is (= "get" (slurp-body resp)))))
 
-(deftest ^{:integration true} sets-conn-timeout
+(deftest sets-conn-timeout
   ;; indirect way of testing if a connection timeout will fail by passing in an
   ;; invalid argument
   (try
@@ -148,21 +152,21 @@
     (catch Exception e
       (is (= IllegalArgumentException (class e))))))
 
-(deftest ^{:integration true} sets-socket-timeout
+(deftest sets-socket-timeout
   (try
     (request {:request-method :get :uri "/timeout" :socket-timeout 1})
     (throw (Exception. "Shouldn't get here."))
     (catch Exception e
       (is (or (= java.net.SocketTimeoutException (class e))
               (= java.net.SocketTimeoutException (class (.getCause e))))))))
 
-(deftest ^{:integration true} delete-with-body
+(deftest delete-with-body
   (let [resp (request {:request-method :delete :uri "/delete-with-body"
                        :body (.getBytes "foo bar")})]
     (is (= 200 (:status resp)))
     (is (= "delete-with-body" (slurp-body resp)))))
 
-(deftest ^{:integration true} self-signed-ssl-get
+(deftest self-signed-ssl-get
   (let [client-opts {:request-method :get
                      :uri "/get"
                      :scheme         :https
@@ -177,7 +181,7 @@
                  (request client-opts))
         "subsequent bad cert fetch throws")))
 
-(deftest ^{:integration true} t-save-request-obj
+(deftest t-save-request-obj
   (let [resp (request {:request-method :post :uri "/post"
                        :body           (.getBytes "foo bar" "UTF-8")
                        :save-request?  true})]
@@ -192,7 +196,57 @@
                :request
                (dissoc :body))))))
 
-(deftest ^{:integration true} t-streaming-response
+(deftest t-streaming-response
   (let [stream (:body (request {:request-method :get :uri "/get" :as :stream}))
         body (slurp stream)]
     (is (= "get" body))))
+
+;;
+;; API level client wrapped requests
+;;
+(deftest roundtrip
+  ;; roundtrip with scheme as a keyword
+  (let [resp (client/request (merge (base-req) {:uri "/get" :method :get}))]
+    (is (= 200 (:status resp)))
+    (is (= "get" (:body resp))))
+  ;; roundtrip with scheme as a string
+  (let [resp (client/request (merge (base-req) {:uri    "/get"
+                                                :method :get
+                                                :scheme "http"}))]
+    (is (= 200 (:status resp)))
+    (is (= "get" (:body resp)))))
+
+(deftest basic-auth-no-creds
+  (let [resp (client/request (merge (base-req) {:method :get
+                                                :uri "/basic-auth"
+                                                :throw-exceptions false}))]
+    (is (= 401 (:status resp)))
+    (is (= "denied" (:body resp)))))
+
+(deftest basic-auth-bad-creds
+  (let [resp (client/request (merge (base-req) {:method :get
+                                                :uri "/basic-auth"
+                                                :throw-exceptions false
+                                                :basic-auth "username:nope"}))]
+    (is (= 401 (:status resp)))
+    (is (= "denied" (:body resp)))))
+
+(deftest basic-auth-creds-as-basic-auth
+  (let [resp (client/request (merge (base-req) {:method :get
+                                                :uri "/basic-auth"
+                                                :basic-auth "username:password"}))]
+    (is (= 200 (:status resp)))
+    (is (= "welcome" (:body resp)))))
+
+(deftest basic-auth-creds-as-user-info
+  (let [resp (client/request (merge (base-req) {:method :get
+                                                :uri "/basic-auth"
+                                                :user-info "username:password"}))]
+    (is (= 200 (:status resp)))
+    (is (= "welcome" (:body resp)))))
+
+(deftest basic-auth-creds-from-url
+  (let [resp (client/request {:method :get
+                              :url (format "http://username:password@localhost:%d/basic-auth" (current-port))})]
+    (is (= 200 (:status resp)))
+    (is (= "welcome" (:body resp)))))