Add tests for the cipher-analyzers module.

.drone.yaml

@@ -0,0 +1,10 @@
+kind: pipeline
+type: docker
+name: default
+
+steps:
+  - name: test
+    image: clojure:temurin-11-lein-2.10.0-alpine
+    commands:
+      - lein test
+

project.clj

@@ -3,7 +3,10 @@
   :url "https://gitlab.com/KKlochko/cipher-analytical-machine"
   :license {:name "LGPL"
             :url "http://www.gnu.org/licenses/lgpl-3.0.txt"}
-  :dependencies [[org.clojure/clojure "1.11.1"]]
+  :dependencies [[org.clojure/clojure "1.11.1"]
+                 [org.clojure/tools.cli "1.0.219"]
+                 [org.apache.tika/tika-core "1.28.5"]
+                 [org.apache.tika/tika-langdetect "1.28.5"]]
   :main ^:skip-aot cipher-analytical-machine.core
   :target-path "target/%s"
   :profiles {:uberjar {:aot :all

src/cipher_analytical_machine/caesar.clj

@@ -0,0 +1,37 @@
+(ns cipher-analytical-machine.caesar
+  (:require [clojure.string :as cs])
+  (:gen-class))
+
+(defn calculate-char-index
+  "Calculate the index of a char."
+  [char symbols]
+  (cs/index-of symbols char))
+
+(defn encrypt-index
+  "Calculates new index of a character. Uses its index, the key and max-index (exclusive)."
+  [index key max-index]
+  (-> index
+       (+ key)
+       (mod max-index)))
+
+(defn encrypt-char
+  "Calculates new index of a character. Uses a char from symbols, the key and max-index (exclusive)."
+  [char key symbols max-index]
+  (get symbols
+       (-> char
+           (calculate-char-index symbols)
+           (encrypt-index key max-index))))
+
+(defn encrypt-message
+  "Encrypt a message using the Caesar cipher."
+  [message key symbols]
+  (let [max-index (count symbols)]
+    (cs/join
+     (map (fn [char] (encrypt-char char key symbols max-index))
+          message))))
+
+(defn decrypt-message
+  "Decrypt the ciphtext using the Caesar cipher."
+  [ciphertext key symbols]
+  (encrypt-message ciphertext (- key) symbols))
+

src/cipher_analytical_machine/caesar_analyzers.clj

@@ -0,0 +1,34 @@
+(ns cipher-analytical-machine.caesar-analyzers
+  (:require [cipher-analytical-machine.caesar :as caesar]
+            [cipher-analytical-machine.cipher-analyzers :as ca])
+  (:gen-class))
+
+(defn get-all-texts
+  "Return a list of pairs which have a key and a second posible plaintext."
+  [ciphertext symbols]
+  (let [keys (range (count symbols))]
+    (reduce
+     (fn [acc key]
+       (conj acc [key (caesar/decrypt-message ciphertext key symbols)]))
+     '() keys)))
+
+(defn get-key
+  "To find the key with frequencies of letters."
+  [ciphertext symbols letter-frequences]
+  (->> (get-all-texts ciphertext symbols)
+       (map (fn [[key text]]
+              [key (ca/chi-squared-statistic text letter-frequences)]))
+       (reduce
+        (fn [[key value] [new-key new-value]]
+          (if (> value new-value) [new-key new-value]
+               [key value]))
+        [0 Double/MAX_VALUE])
+       (first)))
+
+(defn get-plaintext
+  "Return the plaintext from a ciphertext."
+  [ciphertext symbols letter-frequences]
+  (caesar/decrypt-message ciphertext
+                          (get-key ciphertext symbols letter-frequences)
+                          symbols))
+

src/cipher_analytical_machine/cipher_analyzers.clj

@@ -0,0 +1,38 @@
+(ns cipher-analytical-machine.cipher-analyzers
+  (:require [clojure.string :as cs])
+  (:gen-class))
+
+(defn count-characters
+  "Count the letters and return map."
+  [text]
+  (reduce
+   (fn [acc val]
+     (assoc acc val
+            (inc (get acc val 0))))
+   {} text))
+
+(defn chi-squared-letter-statistic
+  "To calculate the frequency distribution of a letter."
+  [letter-count letter-frequence length-text]
+  (let [letter-frequence (* length-text letter-frequence)]
+    (/ (Math/pow
+        (- letter-count letter-frequence) 2)
+       letter-frequence)))
+
+(defn chi-squared-statistic
+  "To calculate the frequency distribution of a language. More detail about the algorithm here: http://practicalcryptography.com/cryptanalysis/text-characterisation/chi-squared-statistic/"
+  [text letter-frequences]
+  (let [length-text (count text)
+        letter-counts (count-characters (cs/lower-case text))]
+    ;letter-counts
+    (reduce
+     (fn [acc [char count]]
+       (+ acc
+          (if (contains? letter-frequences char)
+            (chi-squared-letter-statistic count
+                                          (get letter-frequences char)
+                                          length-text)
+            0)))
+            0
+            letter-counts)))
+

src/cipher_analytical_machine/cli.clj

@@ -0,0 +1,116 @@
+(ns cipher-analytical-machine.cli
+  (:require
+   [cipher-analytical-machine.file :as file]
+   [cipher-analytical-machine.caesar :as caesar]
+   [cipher-analytical-machine.caesar-analyzers :as caesar-analyzers]
+   [cipher-analytical-machine.symbol-factories :as sf]
+   [cipher-analytical-machine.symbol-frequences :as symbol-frequences]
+   [clojure.string :as cs]
+   [clojure.tools.cli :refer [parse-opts]])
+  (:gen-class))
+
+(def cipher-options
+  #{"Caesar"})
+
+(def cli-options
+  [["-m" "--message MESSAGE" "The message will be encrypted or decrypted."]
+   ["-M" "--message-file MESSAGE-FILE" "The file contains the message that will be encrypted or decrypted."]
+   ["-k" "--key KEY" "The key will be used to encrypt or decrypt."]
+   ["-c" "--cipher CIPHER" "The cipher will be used to encrypt or decrypt a message."
+    :default "Caesar"]
+   ["-e" "--encrypt" "Encrypt the message."]
+   ["-d" "--decrypt" "Decrypt the message."]
+   ["-s" "--symbols" "The string will be used as a set of symbols for a cipher."
+    :default (sf/default-symbol-factory "en")]
+   ["-C" "--cracking" "Cracking the encrypted message."]
+   ["-h" "--help"]])
+
+(defn usage [options-summary]
+  (->> ["This is cipher-analytical-machine. It can help you to learn how ciphers works."
+        ""
+        "Usage: cipher-analytical-machine [options]"
+        ""
+        "Options:"
+        options-summary
+        ""]
+       (cs/join \newline)))
+
+(defn error-msg [errors]
+  (str "The following errors occurred while parsing your command:\n\n"
+       (cs/join \newline errors)))
+
+(defn map-has-keys?
+  "Return true if all keys in the map."
+  [map keys]
+  (every? #(contains? map %) keys))
+
+(defn validate-args
+  "Validate command line arguments. Either return a map indicating the program
+  should exit (with an error message, and optional ok status), or a map
+  indicating the action the program should take and the options provided."
+  [args]
+  (let [{:keys [options arguments errors summary]} (parse-opts args cli-options)]
+    (cond
+      (:help options)
+      {:exit-message (usage summary) :ok? true}
+
+      errors
+      {:exit-message (error-msg errors)}
+
+      (map-has-keys? options [:encrypt, :decrypt])
+      {:exit-message (error-msg ["You can't use enctypt and decrypt mode at the same time!!!"])}
+
+      (map-has-keys? options [:message, :message-file])
+      {:exit-message (error-msg ["You can't use message and message-file options at the same time!!!"])}
+
+      (and (map-has-keys? options [:cipher, :key])
+           (or (contains? options :message)
+               (contains? options :message-file))
+           (or (contains? options :encrypt)
+               (contains? options :decrypt)))
+      (cond
+        (contains? options :encrypt)
+        {:options options :arguments arguments :action-type :encrypt}
+
+        (contains? options :decrypt)
+        {:options options :arguments arguments :action-type :decrypt})
+
+      (and (map-has-keys? options [:cipher, :cracking])
+           (or (contains? options :message)
+               (contains? options :message-file)))
+      {:options options :arguments arguments :action-type :cracking}
+
+      :else
+      {:exit-message (usage summary)})))
+
+(defn exit
+  [exit-message status]
+  (println exit-message)
+  (System/exit (if status 0 1)))
+
+(defn get-message
+  "Return the message"
+  [options arguments]
+  (cond
+    (contains? options :message)
+    (:message options)
+
+    (contains? options :message-file)
+    (file/read-file (:message-file options))))
+
+(defn actions
+  [options arguments action-type]
+  (let [message (get-message options arguments)
+        key (Integer/parseInt (:key options))
+        symbols (:symbols options)]
+    (println
+     (cond
+       (= action-type :cracking)
+       (caesar-analyzers/get-plaintext message symbols symbol-frequences/english-letter-frequences)
+
+       (= action-type :encrypt)
+       (caesar/encrypt-message message key symbols)
+
+       (= action-type :decrypt)
+       (caesar/decrypt-message message key symbols)))))
+

src/cipher_analytical_machine/core.clj

@@ -1,7 +1,12 @@
 (ns cipher-analytical-machine.core
+  (:require
+   [cipher-analytical-machine.cli :as cli])
   (:gen-class))
 
 (defn -main
-  "I don't do a whole lot ... yet."
   [& args]
-  (println "Hello, World!"))
+  (let [{:keys [options arguments action-type exit-message ok?]} (cli/validate-args args)]
+    (if exit-message
+      (cli/exit exit-message ok?)
+      (cli/actions options arguments action-type))))
+

src/cipher_analytical_machine/file.clj

@@ -0,0 +1,18 @@
+(ns cipher-analytical-machine.file
+  (:require [clojure.java.io :as io])
+  (:gen-class))
+
+(defn is-file-exists?
+  "Checks that a file is exists"
+  [file-path]
+  (-> (io/file file-path)
+      (.exists)))
+
+(defn is-file-not-exists?
+  "Checks that a file is not exists"
+  [file-path]
+  (not (is-file-exists? file-path)))
+
+(defn read-file [file-path]
+  (slurp file-path))
+

src/cipher_analytical_machine/language_analyzer.clj

@@ -0,0 +1,21 @@
+(ns cipher-analytical-machine.language-analyzer
+  (:import [org.apache.tika.language LanguageIdentifier])
+  (:gen-class))
+
+(defn detect-language
+  "Return a identified language."
+  [text]
+  (-> (new LanguageIdentifier text)
+      .getLanguage))
+
+(defn is-language?
+  "Check if the text written a language."
+  [text language-id]
+  (= (detect-language text)
+     language-id))
+
+(defn is-nonsense?
+  "Check if the text written a language is not a language."
+  [text language-id]
+  (not (is-language? text language-id)))
+

src/cipher_analytical_machine/symbol_factories.clj

@@ -0,0 +1,63 @@
+(ns cipher-analytical-machine.symbol-factories
+  (:require [clojure.string :as cs])
+  (:gen-class))
+
+(defn lower-english-alphabet-factory
+  "Return the English alphabet with only lowercase letters"
+  []
+  (reduce
+   (fn [acc val] (str acc (char val)))
+   ""
+   (range (int \a) (inc (int \z)))))
+
+(defn english-alphabet-factory
+  "Return the English alphabet with lower and upper case letters"
+  []
+  (let [letters (lower-english-alphabet-factory)]
+    (str letters (cs/upper-case letters))))
+
+(defn lower-ukrainian-alphabet-factory
+  "Return the Ukrainian alphabet with only lowercase letters"
+  []
+  "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя")
+
+(defn ukrainian-alphabet-factory
+  "Return the Ukrainian alphabet with lower and upper case letters"
+  []
+  (let [letters (lower-ukrainian-alphabet-factory)]
+    (str letters (cs/upper-case letters))))
+
+(defn digit-set-factory
+  "Return digits"
+  []
+  "0123456789")
+
+(defn punctuation-symbol-factory
+  "Return punctuation symbols"
+  []
+  ".,:;-!?")
+
+(defn space-symbol-factory
+  "Return punctuation symbols"
+  []
+  " \t\n")
+
+(defn default-symbol-factory
+  "Return a default string of symbols for a language"
+  [language-code]
+  (cond
+    (= language-code "en")
+    (str (english-alphabet-factory)
+         (punctuation-symbol-factory)
+         (digit-set-factory)
+         \ )
+
+    (= language-code "uk")
+    (str (ukrainian-alphabet-factory)
+         (punctuation-symbol-factory)
+         (digit-set-factory)
+         \ )
+
+    :else
+    (default-symbol-factory "en")))
+

src/cipher_analytical_machine/symbol_frequences.clj

@@ -0,0 +1,69 @@
+(ns cipher-analytical-machine.symbol-frequences
+  (:gen-class))
+
+(def english-letter-frequences {
+   \a 0.0804
+   \b 0.0154
+   \c 0.0306
+   \d 0.0399
+   \e 0.1251
+   \f 0.0230
+   \g 0.0196
+   \h 0.0549
+   \i 0.0726
+   \j 0.0016
+   \k 0.0067
+   \l 0.0414
+   \m 0.0253
+   \n 0.0709
+   \o 0.0760
+   \p 0.0200
+   \q 0.0011
+   \r 0.0612
+   \s 0.0654
+   \t 0.0925
+   \u 0.0271
+   \v 0.0099
+   \w 0.0192
+   \x 0.0019
+   \y 0.0173
+   \z 0.0009
+})
+
+(def ukrainian-letter-frequences {
+   \а 0.064
+   \б 0.013
+   \в 0.046
+   \г 0.013
+   \ґ 0.0001
+   \д 0.027
+   \е 0.042
+   \є 0.005
+   \ж 0.007
+   \з 0.020
+   \и 0.055
+   \і 0.044
+   \ї 0.010
+   \й 0.009
+   \к 0.033
+   \л 0.027
+   \м 0.029
+   \н 0.068
+   \о 0.086
+   \п 0.025
+   \р 0.043
+   \с 0.037
+   \т 0.045
+   \у 0.027
+   \ф 0.003
+   \х 0.011
+   \ц 0.010
+   \ч 0.011
+   \ш 0.005
+   \щ 0.004
+   \ь 0.016
+   \ю 0.008
+   \я 0.019
+   \  0.138
+})
+

test/cipher_analytical_machine/caesar_test.clj

@@ -0,0 +1,64 @@
+(ns cipher-analytical-machine.caesar-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.caesar :refer :all]
+  ))
+
+(deftest calculate-char-index-test
+  (let [symbols "abc123%$"]
+    (testing "Letter 'b' in symbols"
+      (is (= 1 (calculate-char-index \b symbols))))
+
+    (testing "Letter 'd' does not in symbols"
+      (is (= nil (calculate-char-index \d symbols))))
+
+    (testing "Digit '1' in symbols"
+      (is (= 3 (calculate-char-index \1 symbols))))
+
+    (testing "Digit '0' does not in symbols"
+      (is (= nil (calculate-char-index \0 symbols))))
+
+    (testing "Symbol '?' does not in symbols"
+      (is (= nil (calculate-char-index \? symbols))))))
+
+(deftest encrypt-index-test
+  (testing "The new index is in the range."
+    (is (= 2 (encrypt-index 0 2 33))))
+
+  (testing "The new index that equal to max-index."
+    (is (= 0 (encrypt-index 30 3 33))))
+
+  (testing "The new index that greater than max-index."
+    (is (= 1 (encrypt-index 30 4 33))))
+
+  (testing "The new index that lower than 0."
+    (is (= 32 (encrypt-index 0 -1 33)))))
+
+(deftest encrypt-char-test
+  (let [symbols "abc"
+        max-index (count symbols)]
+    (testing "Letter 'a' is encrypted to 'b'"
+      (is (= \b (encrypt-char \a 1 symbols max-index))))
+
+    (testing "Letter 'b' is encrypted to 'a'"
+      (is (= \a (encrypt-char \b 2 symbols max-index))))
+
+    (testing "Letter 'b' is decryped to 'a'"
+      (is (= \a (encrypt-char \b -1 symbols max-index))))))
+
+(deftest encrypt-message-text
+  (let [symbols "abc"]
+    (testing "The message 'abc' is encrypted to 'bca'"
+      (is (= "bca" (encrypt-message "abc" 1 symbols))))
+
+    (testing "The message 'bca' is decrypted to 'abc'"
+      (is (= "abc" (encrypt-message "bca" -1 symbols))))))
+
+(deftest decrypt-message-text
+  (let [symbols "abc"]
+    (testing "The message 'bca' is decrypted to 'abc'"
+      (is (= "abc" (decrypt-message "bca" 1 symbols)))
+
+    (testing "The message 'abc' is encrypted to 'bca'"
+      (is (= "bca" (decrypt-message "abc" -1 symbols)))))))
+

test/cipher_analytical_machine/cipher_analyzers_test.clj

@@ -0,0 +1,25 @@
+(ns cipher-analytical-machine.cipher-analyzers-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.cipher-analyzers :refer :all]))
+
+(deftest count-characters-test
+  (testing "Count two dublicates and one uniq character from a string."
+    (is (= {\a 2 \b 1}
+           (count-characters "aba")))))
+
+(deftest chi-squared-letter-statistic-test
+  (testing "If the frequence of A is 0.1, the text length is 100 and contains 20 times, then the chi-squared is 10."
+    (is (= 10.0
+           (chi-squared-letter-statistic 20 0.1 100))))
+
+  (testing "If the frequence of A is 0.1, the text length is 10 and contains 5 times, then the chi-squared is 16.0."
+    (is (= 16.0
+           (chi-squared-letter-statistic 5 0.1 10)))))
+
+(deftest chi-squared-statistic-test
+  (let [text "aaaaabbbbb"]
+  (testing "If the frequences of a and b is 0.1, the text length is 10 and contains them 5 times, then score is 32."
+    (is (= 32.0
+           (chi-squared-statistic text {\a 0.1 \b 0.1}))))))
+

test/cipher_analytical_machine/core_test.clj

@@ -2,6 +2,3 @@
   (:require [clojure.test :refer :all]
             [cipher-analytical-machine.core :refer :all]))
 
-(deftest a-test
-  (testing "FIXME, I fail."
-    (is (= 0 1))))

test/cipher_analytical_machine/language_analyzer_test.clj

@@ -0,0 +1,45 @@
+(ns cipher-analytical-machine.language-analyzer-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.language-analyzer :refer :all]
+  ))
+
+(deftest detect-language-test
+  (testing "Checking the English text"
+    (is (= "en" (detect-language "This is a sentence that uses English."))))
+
+  (testing "Checking the Ukrainian text"
+    (is (= "uk" (detect-language "Текст, що написаний українською."))))
+
+  (testing "Checking a gibberish that uses English letters"
+    (is (= "lt" (detect-language "dfgjldfjgdfl gjdfg idfjig hdgesr khs e."))))
+
+  (testing "Checking a gibberish that uses Ukrainian letters"
+    (is (= "uk" (detect-language "іаврпшшцді врадів аргів аріл варї йцґ.")))))
+
+(deftest is-language?-test
+  (testing "Checking the English text"
+    (is (is-language? "This is a sentence that uses English." "en")))
+
+  (testing "Checking the Ukrainian text"
+    (is (is-language? "Текст, що написаний українською." "uk")))
+
+  (testing "Checking a gibberish that uses English letters"
+    (is (is-language? "dfgjldfjgdfl gjdfg idfjig hdgesr khs e." "lt")))
+
+  (testing "Checking a gibberish that uses Ukrainian letters"
+    (is (is-language? "іаврпшшцді врадів аргів аріл варї йцґ." "uk"))))
+
+(deftest is-nonsense?-test
+  (testing "Checking the English text"
+    (is (not (is-nonsense? "This is a sentence that uses English." "en"))))
+
+  (testing "Checking the Ukrainian text"
+    (is (not (is-nonsense? "Текст, що написаний українською." "uk"))))
+
+  (testing "Checking a gibberish that uses English letters"
+    (is (is-nonsense? "dfgjldfjgdfl gjdfg idfjig hdgesr khs e." "en")))
+
+  (testing "Checking a gibberish that uses Ukrainian letters"
+    (is (is-nonsense? "іаврпшшцді івафі лоінїмч йцувіа івапґ." "uk"))))
+

test/cipher_analytical_machine/symbol_factories_test.clj

@@ -0,0 +1,75 @@
+(ns cipher-analytical-machine.symbol-factories-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.symbol-factories :refer :all]
+  ))
+
+(deftest lower-english-alphabet-factory-test
+  (let [symbols (lower-english-alphabet-factory)]
+    (testing "It must have the same order."
+      (is (= "abcdefghijklmnopqrstuvwxyz" symbols)))
+
+    (testing "It must have 26 letters."
+      (is (= 26 (count symbols))))))
+
+(deftest english-alphabet-factory-test
+  (let [symbols (english-alphabet-factory)]
+    (testing "It must have the same order."
+      (is (= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" symbols)))
+
+    (testing "It must have 2*26 letters."
+      (is (= (* 2 26) (count symbols))))))
+
+(deftest lower-ukrainian-alphabet-factory-test
+  (let [symbols (lower-ukrainian-alphabet-factory)]
+    (testing "It must have the same order."
+      (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" symbols)))
+
+    (testing "It must have 33 letters."
+      (is (= 33 (count symbols))))))
+
+(deftest ukrainian-alphabet-factory-test
+  (let [symbols (ukrainian-alphabet-factory)]
+    (testing "It must have the same order."
+      (is (= "абвгґдеєжзиіїйклмнопрстуфхцчшщьюяАБВГҐДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЬЮЯ" symbols)))
+
+    (testing "It must have 2*33 letters."
+      (is (= (* 2 33) (count symbols))))))
+
+(deftest digit-set-factory-test
+  (let [symbols (digit-set-factory)]
+    (testing "It must have the same order."
+      (is (= "0123456789" symbols)))
+
+    (testing "It must have 10 digits."
+      (is (= 10 (count symbols))))))
+
+(deftest punctuation-symbol-factory-test
+  (let [symbols (punctuation-symbol-factory)]
+    (testing "It must have the same order."
+      (is (= ".,:;-!?" symbols)))
+
+    (testing "It must have 7 symbols."
+      (is (= 7 (count symbols))))))
+
+(deftest space-symbol-factory-test
+  (let [symbols (space-symbol-factory)]
+    (testing "It must have the same order."
+      (is (= " \t\n" symbols)))
+
+    (testing "It must have 3 symbols."
+      (is (= 3 (count symbols))))))
+
+(deftest default-symbol-factory-test
+  (testing "If language code is 'en', then it must have symbols."
+    (let [symbols (default-symbol-factory "en")]
+      (is (= 70 (count symbols)))))
+
+  (testing "If language code is 'uk', then it must have symbols."
+    (let [symbols (default-symbol-factory "uk")]
+      (is (= 84 (count symbols)))))
+
+  (testing "If language code is unidentified, then it must have the 'en'."
+    (let [symbols (default-symbol-factory "Maybe a code")]
+      (is (= 70 (count symbols))))))
+