->kebab-case (clj)

(ns camel-snake-kebab.extras-test
  (:require [camel-snake-kebab.core :as csk]
            [camel-snake-kebab.extras :refer [transform-keys]]
            #?(:clj [clojure.test :refer :all]
               :cljs [cljs.test :refer-macros [deftest testing is are]])))

(deftest transform-keys-test
  (are [x y] (= x (transform-keys csk/->kebab-case-keyword y))
    nil nil
    {} {}
    [] []
    {:total-books 0 :all-books []} {'total_books 0 "allBooks" []}
    [{:the-author "Dr. Seuss" :the-title "Green Eggs and Ham"}]
    [{'the-Author "Dr. Seuss" "The_Title" "Green Eggs and Ham"}]
    {:total-books 1 :all-books [{:the-author "Dr. Seuss" :the-title "Green Eggs and Ham"}]}
    {'total_books 1 "allBooks" [{'THE_AUTHOR "Dr. Seuss" "the_Title" "Green Eggs and Ham"}]}))

(deftest transform-keys-with-metadata-test
  (are [x y metadata]
    (let [y-with-metadata (with-meta y metadata)
          y-transformed (transform-keys csk/->kebab-case-keyword y-with-metadata)]
      (and (= x y-transformed)
           (= metadata (meta y-transformed))))
    {} {} {:type-name :metadata-type}
    [] [] {:type-name :check}
    {:total-books 0 :all-books []} {'total_books 0 "allBooks" []} {:type-name :metadata-type}

(ns camel-snake-kebab.core-test
  (:require [camel-snake-kebab.core :as csk]
            #?(:clj [clojure.test :refer :all]
               :cljs [cljs.test :refer-macros [deftest testing is are]]))
  #?(:clj (:import (clojure.lang ExceptionInfo))))

(deftest format-case-test
  (testing "examples"
    (are [x y] (= x y)
      'fluxCapacitor  (csk/->camelCase 'flux-capacitor)
      "I_AM_CONSTANT" (csk/->SCREAMING_SNAKE_CASE "I am constant")
      :object-id      (csk/->kebab-case :object_id)
      "X-SSL-Cipher"  (csk/->HTTP-Header-Case "x-ssl-cipher")
      :object-id      (csk/->kebab-case-keyword "object_id"))
      :s3_key         (csk/->snake_case :s3-key :separator \-))

  (testing "all the type preserving functions"
    (let
      [inputs    ["FooBar"
                  "fooBar"
                  "FOO_BAR"
                  "foo_bar"
                  "foo-bar"
                  "Foo_Bar"]
       functions [csk/->PascalCase
                  csk/->camelCase
                  csk/->SCREAMING_SNAKE_CASE
                  csk/->snake_case
                  csk/->kebab-case
                  csk/->Camel_Snake_Case]
       formats   [identity keyword symbol]]

  (testing "some of the type converting functions"
    (are [x y] (= x y)
      :FooBar   (csk/->PascalCaseKeyword 'foo-bar)
      "FOO_BAR" (csk/->SCREAMING_SNAKE_CASE_STRING :foo-bar)
      'foo-bar  (csk/->kebab-case-symbol "foo bar")))

  (testing "handling of blank input string"
    (is (= "" (csk/->kebab-case "")))
    (is (= "" (csk/->kebab-case " "))))

  (testing "handling of input consisting of only separator(s)"
    (is (= "" (csk/->kebab-case "a" :separator \a)))
    (is (= "" (csk/->kebab-case "aa" :separator \a)))))