add caching and encoding tests

resources/sql/_ds_postgres_cache.sql

@@ -15,9 +15,17 @@ SELECT * FROM :i:cache-table  WHERE "repository" = :repository-name
 -- :name reset-document-cache!
 -- :command :execute
 -- :result :raw
--- :doc creates a new repository table
+-- :doc reset the whole caching table
 DELETE FROM :i:cache-table;
 --;;
 VACUUM (VERBOSE) :i:cache-table;
 --;;
 REINDEX TABLE :i:cache-table;
+
+
+-- :name reset-document-cache-by-repository!
+-- :command :execute
+-- :result :raw
+-- :doc delete only cache from a given repository
+DELETE FROM :i:cache-table WHERE "repository" = :repository-name;
+

src/document_storage/postgres/core.clj

@@ -27,6 +27,7 @@
   (update-repository [this repository] "Update repository settings")
   (delete-repository [this repository] "Delete a repository")
   (reset-cache [this] "Clear and reset the document cache")
+  (reset-repository-cache [this repository] "Clear and reset the document cache for one repository")
   (cached-repository? [this repository] "Checks if the repository will use caching")
   (run-query [this query-key params] "Run a Query on a DB-based Storage"))
 ;;;TODO cached-document? method
@@ -78,6 +79,8 @@
                     (merge table-names params))))
   (reset-cache [this]
     (.run-query this :reset-document-cache! {}))
+  (reset-repository-cache [this repository]
+    (.run-query this :reset-document-cache-by-repository! {:repository repository}))
   (cached-repository? [this repository]
     (let [repo-info (run-query this :get-repository-info
                                {:repository repository})]

src/document_storage/postgres/documents.clj

@@ -48,11 +48,14 @@
                    :version version
                    :repository repository}))))))
 
+(defn get-cached-document [storage repository document-id version]
+  (.run-query storage :get-cached-document
+              {:repository repository
+               :document-id document-id
+               :version version}))
+
 (defn load-cached-document [storage repository document-id version load-doc-fn]
-  (if-let [document (.run-query storage :get-cached-document
-                                {:repository repository
-                                 :document-id document-id
-                                 :version version})]
+  (if-let [document (get-cached-document storage repository document-id version)]
     (encoding/decode-document (:data document))
     (let [restored-document (load-doc-fn)]
       (.run-query storage :create-document-cache!

test/document_storage/postgres/caching_test.clj

+(ns document-storage.postgres.caching-test
+  (:require [clojure.test :refer :all]
+            [document-storage.core :as ds]
+            [document-storage.postgres.core :as dspostgres]
+            [clojure.java.io :as io]
+            [fipp.edn :refer [pprint] :rename {pprint fipp}]
+            [document-storage.protocol :as dsprot]
+            [environ.core :refer [env]]
+            [document-storage.protocol-test :as protocol-tests]
+            [document-storage.postgres.core-test :refer [ds-atom storage-fixture]]
+            [document-storage.postgres.documents :as pgdocs]
+            [document-storage.testdata :refer [generate-document]]
+            [clj-helper.string :refer [get-unique-id]]))
+
+
+
+(use-fixtures :once storage-fixture)
+
+(deftest test-repository-caching
+  (testing "check if documents are cached and reset cache will remove cached documents"
+    (let [repo1name (str (gensym "r1"))
+          repo2name (str (gensym "r2"))]
+      (.create-repository @ds-atom {:name repo1name
+                                    :caching true
+                                    :versioning true})
+      (.create-repository @ds-atom {:name repo2name
+                                    :caching true
+                                    :versioning true})
+      (let [docname1 (get-unique-id "tdoc")
+            new-document1 (generate-document)
+            docname2 (get-unique-id "tdoc")
+            new-document2 (generate-document)]
+        ;;;Create Testdocument in each repository
+        (.save-document @ds-atom docname1 new-document1 repo1name)
+        (.save-document @ds-atom docname2 new-document2 repo2name)
+        (let [last-version1 (pgdocs/get-last-document-version @ds-atom docname1 repo1name)
+              last-version2 (pgdocs/get-last-document-version @ds-atom docname2 repo2name)]
+          ;;; Check if inital versions are not cached
+          (is (nil? (pgdocs/get-cached-document @ds-atom repo1name docname1 last-version1)) "Initial documents are not cached")
+          (is (nil? (pgdocs/get-cached-document @ds-atom repo2name docname2 last-version2)) "Initial documents are not cached")
+          ;;; Load doc1 and check if its cached - doc2 should not be cached
+          (.load-document @ds-atom docname1 repo1name)
+          (is (not (nil? (pgdocs/get-cached-document @ds-atom repo1name docname1 last-version1))) "Documents should be cached after being loaded at least once")
+          (is (nil? (pgdocs/get-cached-document @ds-atom repo2name docname2 last-version2)) "Unloaded docs are not cached")
+          ;;; Now load doc1 and check if its also cached
+          (.load-document @ds-atom docname2 repo2name)
+          (is (not (nil? (pgdocs/get-cached-document @ds-atom repo2name docname2 last-version2))) "Documents should be cached after being loaded at least once")
+
+          ;;; Reset repository cache and check if its only reset the chosen repository cache
+          (.reset-repository-cache @ds-atom repo1name)
+          (is (nil? (pgdocs/get-cached-document @ds-atom repo1name docname1 last-version1)) "Documents should not be cached after repository-cache reset")
+          (is (not (nil? (pgdocs/get-cached-document @ds-atom repo2name docname2 last-version2))) "Documents should be cached if another repository is reset")
+          ;;; Reset complete cache and check if it cleared the remaining cache for repo2
+          (.reset-cache @ds-atom)
+          (is (nil? (pgdocs/get-cached-document @ds-atom repo2name docname2 last-version2)) "Documents should not be cached if the whole cache was reset")))
+      (.delete-repository @ds-atom repo1name)
+      (.delete-repository @ds-atom repo2name))))

test/document_storage/postgres/core_test.clj

@@ -61,8 +61,3 @@
       (is (= (.versioned-repository? @ds-atom reponame) false) "Updated repo with versioning false should return false for versioned-repository? method")
 
       (.delete-repository @ds-atom reponame))))
-
-
-;;;TODO reset-cache
-
-;;;TODO test if versioning/caching parameters are set correctly for new repositories

test/document_storage/postgres/encoding_test.clj

 (ns document-storage.postgres.encoding-test
-  (:require [document-storage.postgres.encoding :as sut]
-            [clojure.test :as t]))
+  (:require [clojure.test :refer :all]
+            [document-storage.postgres.encoding :as sut]
+            [document-storage.testdata :refer [generate-document]]))
 
+
+
+(deftest test-encoding-roundtrip
+  (testing "Test if a new document can be encoded and then decoded without loss"
+    (let [new-document (generate-document)]
+      (is (= (-> new-document
+                 sut/encode-document
+                 sut/decode-document)
+             new-document)))))
+
+(deftest test-transit-encoding-roundtrip
+  (testing "Test if a new document can be encoded to transit and then decoded without loss"
+    (let [new-document (generate-document)]
+      (is (= (-> new-document
+                 sut/document->transit
+                 sut/transit->document)
+             new-document)))))