From f0755abf1e0a5e180972dc6aec4d3e9a5d03487a Mon Sep 17 00:00:00 2001 From: car031 Date: Tue, 6 Jun 2023 15:48:12 +0200 Subject: [PATCH] More unit tests --- .../logicaldoc/core/automation/DocTool.java | 5 +- .../core/automation/FolderTool.java | 23 +- .../core/security/SessionManager.java | 10 +- .../logicaldoc/core/AbstractCoreTCase.java | 1 + .../core/automation/DocToolTest.java | 398 ++++++++++++++++++ .../core/automation/FolderToolTest.java | 134 ++++++ .../document/DocumentManagerImplTest.java | 4 +- .../core/security/SessionManagerTest.java | 262 ++++++++++-- logicaldoc-core/src/test/resources/data.sql | 8 +- .../soap/endpoint/SoapAuthServiceTest.java | 6 +- 10 files changed, 801 insertions(+), 50 deletions(-) create mode 100644 logicaldoc-core/src/test/java/com/logicaldoc/core/automation/DocToolTest.java create mode 100644 logicaldoc-core/src/test/java/com/logicaldoc/core/automation/FolderToolTest.java diff --git a/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/DocTool.java b/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/DocTool.java index 3d9590a71..64f0a8e91 100644 --- a/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/DocTool.java +++ b/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/DocTool.java @@ -301,8 +301,10 @@ public Document copy(Document doc, String targetPath, String username) { * @param doc1 first document * @param doc2 second document * @param type type of link(optional) + * + * @return the created link */ - public void link(Document doc1, Document doc2, String type) { + public DocumentLink link(Document doc1, Document doc2, String type) { DocumentLinkDAO linkDao = (DocumentLinkDAO) Context.get().getBean(DocumentLinkDAO.class); DocumentLink link = linkDao.findByDocIdsAndType(doc1.getId(), doc2.getId(), "default"); if (link == null) { @@ -318,6 +320,7 @@ public void link(Document doc1, Document doc2, String type) { log.error(e.getMessage(), e); } } + return link; } /** diff --git a/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/FolderTool.java b/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/FolderTool.java index 77e49b367..abae1d6e1 100644 --- a/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/FolderTool.java +++ b/logicaldoc-core/src/main/java/com/logicaldoc/core/automation/FolderTool.java @@ -86,7 +86,7 @@ public String getPath(Long folderId) throws PersistenceException { FolderDAO folderDao = (FolderDAO) Context.get().getBean(FolderDAO.class); return folderDao.computePathExtended(folderId); } - + /** * Finds the folder by it's path * @@ -116,6 +116,23 @@ public Folder findByPath(String path, Long tenantId) { } } + /** + * Finds the folder by it's identifier + * + * @param id the unique identifier + * + * @return the found folder + */ + public Folder findById(long id) { + FolderDAO folderDao = (FolderDAO) Context.get().getBean(FolderDAO.class); + try { + return folderDao.findById(id); + } catch (PersistenceException e) { + log.error(e.getMessage(), e); + return null; + } + } + /** * Saves / updates a folder into the database * @@ -188,7 +205,7 @@ public void delete(long folderId, String username) throws PersistenceException { public void move(Folder folder, String targetPath, String username) throws PersistenceException { User user = new SecurityTool().getUser(username); - Folder target = createPath(null, targetPath, username); + Folder target = createPath(folder, targetPath, username); FolderHistory transaction = new FolderHistory(); transaction.setFolder(folder); @@ -225,7 +242,7 @@ public Folder copy(Folder source, String targetPath, boolean foldersOnly, String throws PersistenceException { User user = new SecurityTool().getUser(username); - Folder target = createPath(null, targetPath, username); + Folder target = createPath(source, targetPath, username); FolderHistory transaction = new FolderHistory(); transaction.setFolder(source); diff --git a/logicaldoc-core/src/main/java/com/logicaldoc/core/security/SessionManager.java b/logicaldoc-core/src/main/java/com/logicaldoc/core/security/SessionManager.java index 1eff0ae7f..2b3b4b448 100644 --- a/logicaldoc-core/src/main/java/com/logicaldoc/core/security/SessionManager.java +++ b/logicaldoc-core/src/main/java/com/logicaldoc/core/security/SessionManager.java @@ -210,12 +210,10 @@ public Session remove(Object sid) { public void renew(String sid) { if (isOpen(sid)) { Session session = get(sid); - if (session.getStatus() == Session.STATUS_OPEN) { - if (session.isTimedOut()) { - session.setExpired(); - } else { - session.setLastRenew(new Date()); - } + if (session.isTimedOut()) { + session.setExpired(); + } else { + session.setLastRenew(new Date()); } } } diff --git a/logicaldoc-core/src/test/java/com/logicaldoc/core/AbstractCoreTCase.java b/logicaldoc-core/src/test/java/com/logicaldoc/core/AbstractCoreTCase.java index 8bc3536e4..5f2bf6361 100644 --- a/logicaldoc-core/src/test/java/com/logicaldoc/core/AbstractCoreTCase.java +++ b/logicaldoc-core/src/test/java/com/logicaldoc/core/AbstractCoreTCase.java @@ -69,6 +69,7 @@ private void prepareStore() throws IOException { // Store the file of document 1 FileUtil.copyResource("/Digital_Day.pdf", new File(storePath+"/1/doc/1.0")); + FileUtil.copyResource("/Digital_Day.pdf", new File(storePath+"/1/doc/1.0-conversion.pdf")); // Store the file of document 3 FileUtil.copyResource("/small.pdf", new File(storePath+"/3/doc/1.3")); diff --git a/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/DocToolTest.java b/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/DocToolTest.java new file mode 100644 index 000000000..526c2a571 --- /dev/null +++ b/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/DocToolTest.java @@ -0,0 +1,398 @@ +package com.logicaldoc.core.automation; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; + +import com.logicaldoc.core.AbstractCoreTCase; +import com.logicaldoc.core.document.AbstractDocument; +import com.logicaldoc.core.document.Document; +import com.logicaldoc.core.document.DocumentEvent; +import com.logicaldoc.core.document.DocumentHistory; +import com.logicaldoc.core.document.DocumentLink; +import com.logicaldoc.core.folder.Folder; +import com.logicaldoc.core.metadata.Template; +import com.logicaldoc.core.metadata.TemplateDAO; +import com.logicaldoc.core.security.Tenant; + +import junit.framework.Assert; + +public class DocToolTest extends AbstractCoreTCase { + + // instance under test + private DocTool testSubject = new DocTool(); + + @Test + public void testDownloadUrl() throws Exception { + String url = testSubject.downloadUrl(1L); + assertEquals("http://localhost:8080/download?docId=1", url); + + DocumentHistory hist = new DocumentHistory(); + hist.setDocId(2L); + url = testSubject.downloadUrl(hist); + assertEquals("http://localhost:8080/download?docId=2", url); + } + + @Test + public void testDisplayUrl() throws Exception { + String url = testSubject.displayUrl(new Document()); + assertEquals("http://localhost:8080/display?tenant=default&docId=0", url); + + DocumentHistory hist = new DocumentHistory(); + hist.setDocId(2L); + url = testSubject.displayUrl(hist); + assertEquals("http://localhost:8080/display?tenant=default&docId=2", url); + } + + @Test + public void testDownloadTicket() throws Exception { + String url = testSubject.downloadTicket(1L, true, 1, null, 3, "admin"); + assertTrue(url.startsWith("http://localhost:8080/download-ticket?ticketId=")); + } + + @Test + public void testDisplayFileSize() throws Exception { + final long kb = 1024L; + String result = testSubject.displayFileSize(kb); + assertEquals("1 KB", result); + + result = testSubject.displayFileSize(kb * kb); + assertEquals("1 MB", result); + + result = testSubject.displayFileSize(kb * kb * kb); + assertEquals("1 GB", result); + + result = testSubject.displayFileSize(1L); + assertEquals("1 Bytes", result); + } + + @Test + public void testStore() throws Exception { + Document doc = new Document(); + doc.setFileName("test.pdf"); + final Folder folder = new FolderTool().findById(4L); + doc.setFolder(folder); + + DocumentHistory transaction = new DocumentHistory(); + transaction.setDocument(doc); + transaction.setUserId(1L); + transaction.setUsername("admin"); + transaction.setUserLogin("admin"); + + testSubject.store(doc, transaction); + assertNotSame(0L, doc.getId()); + + doc = new Document(); + doc.setFileName("test2.pdf"); + doc.setFolder(folder); + testSubject.store(doc); + assertNotSame(0L, doc.getId()); + + doc = new Document(); + doc.setFileName("test3.pdf"); + doc.setFolder(folder); + testSubject.store(doc, "admin"); + assertNotSame(0L, doc.getId()); + } + + @Test + public void testInitialize() throws Exception { + TemplateDAO templateDao = (TemplateDAO) context.getBean("TemplateDAO"); + Template template = templateDao.findById(-1L); + + final Folder folder = new FolderTool().findById(4L); + + Document doc = new Document(); + doc.setFolder(folder); + doc.setTemplate(template); + doc.setFileName("pippo.pdf"); + + doc.setValues("multi", new String[] { "value1", "value2", "value3" }); + testSubject.store(doc); + assertNotSame(0L, doc.getId()); + + doc = testSubject.findById(doc.getId()); + testSubject.initialize(doc); + assertEquals(3, doc.getValues("multi").size()); + assertEquals("value1", doc.getValues("multi").get(0)); + } + + @Test + public void testMove() throws Exception { + FolderTool ft = new FolderTool(); + Folder testFolder = ft.createPath(ft.findById(4L), "/Default/test", "admin"); + Document doc = testSubject.findById(1L); + assertNotNull(doc); + testSubject.initialize(doc); + testSubject.move(doc, "/Default/test", "admin"); + + doc = testSubject.findByPath("/Default/test/pippo.pdf"); + assertEquals(1L, doc.getId()); + assertEquals(testFolder, doc.getFolder()); + } + + @Test + public void testCopy() throws Exception { + FolderTool ft = new FolderTool(); + Folder testFolder = ft.createPath(ft.findById(4L), "/Default/test", "admin"); + Document doc = testSubject.findById(1L); + Document copied = testSubject.copy(doc, "/Default/test", "admin"); + assertEquals(testFolder, copied.getFolder()); + assertNotSame(doc, copied); + assertNotSame(doc.getFolder(), copied.getFolder()); + + } + + @Test + public void testLink() throws Exception { + Document doc1 = testSubject.findById(1); + Document doc2 = testSubject.findById(2); + DocumentLink link = testSubject.link(doc1, doc2, "test"); + assertNotNull(link); + assertTrue(link.getId() > 0L); + } + + @Test + public void testCreateAlias() throws Exception { + Document doc = testSubject.findById(1); + Assert.assertNotNull(doc); + testSubject.initialize(doc); + + FolderTool folderTool = new FolderTool(); + Folder newFolder = folderTool.findById(6); + folderTool.initialize(newFolder); + + Document alias = testSubject.createAlias(doc, newFolder, null, "admin"); + Assert.assertNotSame(doc.getId(), alias.getId()); + Assert.assertEquals(newFolder, alias.getFolder()); + Assert.assertEquals("pippo(1).pdf", alias.getFileName()); + + alias = testSubject.createAlias(doc, folderTool.getPath(newFolder.getId()), null, "admin"); + Assert.assertNotSame(doc.getId(), alias.getId()); + Assert.assertEquals(newFolder, alias.getFolder()); + Assert.assertEquals("pippo(2).pdf", alias.getFileName()); + } + + @Test + public void testLock() throws Exception { + Document doc = testSubject.findById(1); + Assert.assertNotNull(doc); + testSubject.lock(doc.getId(), "admin"); + doc = testSubject.findById(1); + Assert.assertEquals(2, doc.getStatus()); + Assert.assertEquals(1L, doc.getLockUserId().longValue()); + + // double lock with same user just to check that no exceptions are + // raised + testSubject.lock(doc.getId(), "admin"); + testSubject.lock(doc.getId(), "admin"); + } + + @Test + public void testUnlock() throws Exception { + testSubject.lock(1L, "admin"); + + Document doc = testSubject.findById(1L); + Assert.assertEquals(2, doc.getStatus()); + Assert.assertEquals(1L, doc.getLockUserId().longValue()); + + // Locked by a different user + testSubject.unlock(doc.getId(), "admin"); + + doc = testSubject.findById(1); + Assert.assertEquals(0, doc.getStatus()); + Assert.assertNull(doc.getLockUserId()); + + testSubject.unlock(doc.getId(), "admin"); + + doc = testSubject.findById(1); + Assert.assertEquals(AbstractDocument.DOC_UNLOCKED, doc.getStatus()); + Assert.assertNull(doc.getLockUserId()); + + // Already unlocked + testSubject.unlock(doc.getId(), "admin"); + doc = testSubject.findById(1); + Assert.assertEquals(AbstractDocument.DOC_UNLOCKED, doc.getStatus()); + Assert.assertNull(doc.getLockUserId()); + } + + @Test + public void testDelete() throws Exception { + Document doc = testSubject.findById(1L); + assertNotNull(doc); + assertTrue(doc.getId() > 0L); + + testSubject.delete(1L, "admin"); + doc = testSubject.findById(1L); + assertNull(doc); + } + + @Test + public void testCopyResource() throws Exception { + Document doc = testSubject.findById(1L); + Document result = testSubject.copyResource(doc, doc.getFileVersion(), "conversion.pdf", "xxx.pdf", "admin"); + assertNotNull(result); + assertTrue(result.getId() > 0L); + assertEquals("xxx.pdf", result.getFileName()); + assertTrue(result.getFileSize() > 0L); + } + + @Test + public void testReadAsString() throws Exception { + Document doc = testSubject.findById(1L); + String result = testSubject.readAsString(doc.getId(), doc.getFileVersion(), null); + assertNotNull(result); + assertTrue(result.contains("Linearized")); + } + + @Test + public void testWriteToFile() throws Exception { + Document doc = testSubject.findById(1L); + testSubject.writeToFile(1L, doc.getFileVersion(), "conversion.pdf", "target/test.pdf"); + File extraction = new File("target/test.pdf"); + assertTrue(extraction.exists()); + assertTrue(extraction.length() > 0); + extraction.delete(); + } + + @Test + public void testConvert() throws Exception { + Document doc = testSubject.findById(1L); + testSubject.convertPDF(doc); + Document result = testSubject.convert(doc, "pdf", "admin"); + assertNotNull(result); + } + + @Test + public void testMerge() throws Exception { + Document doc1 = testSubject.findById(1); + Assert.assertNotNull(doc1); + testSubject.initialize(doc1); + Assert.assertEquals(55, testSubject.countPages(doc1)); + + Document doc3 = testSubject.findById(3); + Assert.assertNotNull(doc3); + testSubject.initialize(doc3); + Assert.assertEquals(1, testSubject.countPages(doc3)); + + Document mergedDoc = testSubject.merge(Arrays.asList(doc1, doc3), 1200L, "merged.pdf", "admin"); + Assert.assertNotNull(mergedDoc); + + mergedDoc = testSubject.findById(mergedDoc.getId()); + Assert.assertNotNull(mergedDoc); + testSubject.initialize(mergedDoc); + + Assert.assertEquals(56, testSubject.countPages(mergedDoc)); + } + + + @Test + public void testFindByPath() throws Exception { + Document doc = testSubject.findById(1L); + String path=testSubject.getPath(doc); + Document pathDoc = testSubject.findByPath(path); + assertEquals(doc, pathDoc); + } + + + @Test + public void testGetPath() throws Exception { + String result = testSubject.getPath(testSubject.findById(1L)); + assertEquals("/Workspace X/folder6/pippo.pdf", result); + } + + @Test + public void testGetIds() throws Exception { + Document doc1=new Document(); + doc1.setId(101L); + Document doc2=new Document(); + doc2.setId(102L); + Document doc3=new Document(); + doc3.setId(103L); + List ids =testSubject.getIds(Arrays.asList(doc1, doc2, doc3)); + Assert.assertEquals(3, ids.size()); + Assert.assertEquals(Long.valueOf(102L), ids.get(1)); + } + + @Test + public void testCreatePath() throws Exception { + Document doc = testSubject.findById(1L); + Folder result = testSubject.createPath(doc, "/Default/xxx", "admin"); + FolderTool ft = new FolderTool(); + assertEquals(result, ft.findByPath("/Default/xxx", doc.getTenantId())); + + result = testSubject.createPath(doc, "yyy", "admin"); + assertEquals(result, ft.findByPath("/Workspace X/folder6/yyy", doc.getTenantId())); + + result = testSubject.createPath(doc, "/zzz", "admin"); + assertEquals(result, ft.findByPath("/Default/zzz", doc.getTenantId())); + } + + @Test + public void testGetHistories() throws Exception { + List result = testSubject.getHistories(1L, null); + assertEquals(3, result.size()); + + result = testSubject.getHistories(1L, DocumentEvent.STORED.toString()); + assertEquals(0, result.size()); + } + + @Test + public void testAddNote() throws Exception { + Document doc = testSubject.findById(1L); + assertEquals(2, testSubject.getNotes(1L, null).size()); + + testSubject.addNote(doc, "my note", "admin"); + assertEquals(3, testSubject.getNotes(1L, null).size()); + assertEquals(3, testSubject.getNotes(1L, doc.getFileVersion()).size()); + } + + @Test + public void testCalculateNextVersion() throws Exception { + String result = testSubject.calculateNextVersion("1.1", true); + assertEquals("2.0", result); + result = testSubject.calculateNextVersion("1.1", false); + assertEquals("1.2", result); + } + + @Test + public void testFindTemplateByName() throws Exception { + Template template = testSubject.findTemplateByName("email", Tenant.DEFAULT_ID); + assertNotNull(template); + assertEquals("email", template.getName()); + + template = testSubject.findTemplateByName("unexisting", Tenant.DEFAULT_ID); + assertNull(template); + } + + @Test + public void testFindTemplateById() throws Exception { + Template template = testSubject.findTemplateById(-1L); + assertNotNull(template); + assertEquals("default", template.getName()); + + template = testSubject.findTemplateById(999L); + assertNull(template); + } + + @Test + public void testCountPages() throws Exception { + Document doc = testSubject.findById(1L); + assertEquals(55, testSubject.countPages(doc)); + } + + @Test + public void testParse() throws Exception { + Document doc = testSubject.findById(1); + String text = testSubject.parse(doc, doc.getFileVersion()); + Assert.assertTrue(text.contains("Digital Day")); + } +} \ No newline at end of file diff --git a/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/FolderToolTest.java b/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/FolderToolTest.java new file mode 100644 index 000000000..7bf15e181 --- /dev/null +++ b/logicaldoc-core/src/test/java/com/logicaldoc/core/automation/FolderToolTest.java @@ -0,0 +1,134 @@ +package com.logicaldoc.core.automation; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import org.junit.Test; + +import com.logicaldoc.core.AbstractCoreTCase; +import com.logicaldoc.core.folder.Folder; +import com.logicaldoc.core.folder.FolderHistory; +import com.logicaldoc.core.security.Tenant; + +public class FolderToolTest extends AbstractCoreTCase { + + // instance under test + private FolderTool testSubject = new FolderTool(); + + @Test + public void testDisplayUrl() throws Exception { + String result = testSubject.displayUrl(Tenant.DEFAULT_ID, 6L); + assertEquals("http://localhost:8080/display?tenant=default&folderId=6", result); + + Folder fold = new Folder(); + fold.setId(6L); + result = testSubject.displayUrl(fold); + assertEquals("http://localhost:8080/display?tenant=default&folderId=6", result); + + FolderHistory hist = new FolderHistory(); + hist.setFolder(fold); + hist.setFolderId(6L); + result = testSubject.displayUrl(hist); + assertEquals("http://localhost:8080/display?tenant=default&folderId=6", result); + } + + @Test + public void testGetPath() throws Exception { + String result = testSubject.getPath(6L); + assertEquals("/Workspace X/folder6", result); + } + + @Test + public void testFindByPath() throws Exception { + Folder result = testSubject.findByPath("/Workspace X/folder6"); + assertNotNull(result); + assertEquals(6L, result.getId()); + } + + @Test + public void testFindById() throws Exception { + Folder result = testSubject.findById(6L); + assertNotNull(result); + assertEquals(6L, result.getId()); + assertEquals("folder6", result.getName()); + } + + @Test + public void testStore() throws Exception { + Folder folder = new Folder(); + folder.setParentId(6L); + folder.setName("newfolder"); + + testSubject.store(folder, "admin"); + Folder result = testSubject.findByPath("/Workspace X/folder6/newfolder"); + testSubject.initialize(folder); + assertNotNull(result); + assertEquals("newfolder", result.getName()); + } + + @Test + public void testDelete() throws Exception { + Folder folder = testSubject.findById(6L); + assertNotNull(folder); + + testSubject.delete(6L, "admin"); + folder = testSubject.findById(6L); + assertNull(folder); + } + + @Test + public void testMove() throws Exception { + Folder folder = testSubject.findById(1202L); + assertNotNull(folder); + assertEquals("xyz", folder.getName()); + testSubject.move(folder, "/Workspace X/folder6", "admin"); + + Folder movedFolder = testSubject.findByPath("/Workspace X/folder6/xyz"); + assertEquals(folder, movedFolder); + } + + @Test + public void testCopy() throws Exception { + Folder folder = testSubject.findById(1202L); + Folder copied = testSubject.copy(folder, "/Workspace X/folder6", true, "inherit", "admin"); + Folder movedFolder = testSubject.findByPath("/Workspace X/folder6/xyz"); + assertEquals(copied, movedFolder); + } + + @Test + public void testMerge() throws Exception { + Folder source = testSubject.findById(6L); + assertNotNull(source); + assertEquals("/Workspace X/folder6", testSubject.getPath(source.getId())); + + testSubject.createPath(source, "test", "admin"); + + Folder target = testSubject.findById(1202L); + assertNotNull(target); + String targetPath = testSubject.getPath(target.getId()); + + System.out.println(targetPath); + + testSubject.merge(source, target, "admin"); + target = testSubject.findById(6L); + assertNull(target); + assertNotNull(testSubject.findByPath(targetPath + "/test")); + } + + @Test + public void testCreatePath() throws Exception { + Folder folder = testSubject.findById(6L); + assertNotNull(folder); + + Folder path = testSubject.createPath(folder, "/Workspace X/folder6/abc", "admin"); + assertNotNull(path); + assertEquals("abc", path.getName()); + assertEquals("/Workspace X/folder6/abc", testSubject.getPath(path.getId())); + + path = testSubject.createPath(folder, "123/def", "admin"); + assertNotNull(path); + assertEquals("def", path.getName()); + assertEquals("/Workspace X/folder6/123/def", testSubject.getPath(path.getId())); + } +} \ No newline at end of file diff --git a/logicaldoc-core/src/test/java/com/logicaldoc/core/document/DocumentManagerImplTest.java b/logicaldoc-core/src/test/java/com/logicaldoc/core/document/DocumentManagerImplTest.java index 55296c03f..48a99c9fe 100644 --- a/logicaldoc-core/src/test/java/com/logicaldoc/core/document/DocumentManagerImplTest.java +++ b/logicaldoc-core/src/test/java/com/logicaldoc/core/document/DocumentManagerImplTest.java @@ -11,7 +11,6 @@ import java.io.InputStream; import java.util.Arrays; import java.util.Calendar; -import java.util.Date; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -277,8 +276,7 @@ public void testEnforceFilesIntoFolderStorage() transaction = new DocumentHistory(); transaction.setUser(user); - Assert.assertEquals(1, documentManager.enforceFilesIntoFolderStorage(folder.getId(), transaction)); - + Assert.assertEquals(2, documentManager.enforceFilesIntoFolderStorage(folder.getId(), transaction)); Assert.assertTrue(new File(store2Root + "/1/doc/" + doc.getFileVersion()).exists()); } diff --git a/logicaldoc-core/src/test/java/com/logicaldoc/core/security/SessionManagerTest.java b/logicaldoc-core/src/test/java/com/logicaldoc/core/security/SessionManagerTest.java index aa25c4487..f12c236bf 100644 --- a/logicaldoc-core/src/test/java/com/logicaldoc/core/security/SessionManagerTest.java +++ b/logicaldoc-core/src/test/java/com/logicaldoc/core/security/SessionManagerTest.java @@ -1,54 +1,186 @@ package com.logicaldoc.core.security; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +import javax.servlet.http.Cookie; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; + +import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.security.core.context.SecurityContextHolder; import com.logicaldoc.core.AbstractCoreTCase; +import com.logicaldoc.core.PersistenceException; +import com.logicaldoc.core.security.authentication.AuthenticationException; +import com.logicaldoc.core.security.dao.UserDAO; +import com.logicaldoc.core.security.spring.LDAuthenticationToken; +import com.logicaldoc.core.security.spring.LDSecurityContextRepository; import com.logicaldoc.util.Context; import com.logicaldoc.util.config.ContextProperties; -import junit.framework.Assert; - /** * Test case for the SessionManager * * @author Marco Meschieri - LogicalDOC * @since 4.6 */ -public class SessionManagerTest extends AbstractCoreTCase { +@RunWith(MockitoJUnitRunner.class) +public class SessionManagerTest extends AbstractCoreTCase implements SessionListener { + + // instance under test + private SessionManager testSubject; + + @Mock + private HttpServletRequest request; + + @Mock + private HttpSession httpSession; + + @Mock + private HttpServletResponse response; + + @Mock + private Client client; @Before public void setUp() throws Exception { super.setUp(); + testSubject = SessionManager.get(); + testSubject.addListener(this); + + when(client.getId()).thenReturn("testid"); + when(request.getHeader("Authorization")).thenReturn("Basic YWRtaW46YWRtaW4="); + } + + @After + public void tearDown() throws Exception { + testSubject.removeListener(this); + testSubject.destroy(); + super.tearDown(); } @Test - public void testNewSession() { - SessionManager sm = SessionManager.get(); - sm.clear(); - Session session1 = sm.newSession("admin", "admin", null); - Assert.assertNotNull(session1); - Session session2 = sm.newSession("admin", "admin", null); - Assert.assertNotNull(session2); - Assert.assertNotSame(session1, session2); - Assert.assertEquals(2, sm.getSessions().size()); + public void testNewSession() throws AuthenticationException, PersistenceException { + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); + Session session2 = testSubject.newSession("admin", "admin", null); + assertNotNull(session2); + assertNotSame(session1, session2); + assertEquals(2, testSubject.getSessions().size()); + + UserDAO uDao = (UserDAO) Context.get().getBean(UserDAO.class); + Session session3 = testSubject.createSession(uDao.findById(1L), client); + assertNotNull(session3); + assertEquals(3, testSubject.getSessions().size()); } @Test public void testKill() { - SessionManager sm = SessionManager.get(); - sm.clear(); - Session session1 = sm.newSession("admin", "admin", null); - Assert.assertNotNull(session1); - Session session2 = sm.newSession("admin", "admin", null); - Assert.assertNotNull(session2); - Assert.assertNotSame(session1, session2); - Assert.assertEquals(2, sm.getSessions().size()); + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); + Session session2 = testSubject.newSession("admin", "admin", null); + assertNotNull(session2); + assertNotSame(session1, session2); + assertEquals(2, testSubject.getSessions().size()); - sm.kill(session1.getSid()); - Assert.assertTrue(sm.isOpen(session2.getSid())); - Assert.assertTrue(!sm.isOpen(session1.getSid())); - Assert.assertEquals(2, sm.getSessions().size()); + testSubject.kill(session1.getSid()); + assertTrue(testSubject.isOpen(session2.getSid())); + assertTrue(!testSubject.isOpen(session1.getSid())); + assertEquals(2, testSubject.getSessions().size()); + } + + @Test + public void testRemove() { + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); + Session session2 = testSubject.newSession("admin", "admin", null); + assertNotNull(session2); + assertNotSame(session1, session2); + assertEquals(2, testSubject.getSessions().size()); + + testSubject.remove(session1.getSid()); + assertTrue(testSubject.isOpen(session2.getSid())); + assertEquals(1, testSubject.getSessions().size()); + } + + @Test + public void testRemoveSid() { + testSubject.clear(); + Session session = testSubject.newSession("admin", "admin", null); + assertNotNull(session); + + when(request.getSession(false)).thenReturn(httpSession); + + LDSecurityContextRepository.bindServletSession(session.getSid(), httpSession); + + LDAuthenticationToken authentication=new LDAuthenticationToken("admin"); + authentication.setSid(session.getSid()); + SecurityContextHolder.getContext().setAuthentication(authentication); + + testSubject.removeSid(request); + assertNull(testSubject.getSessionId(request)); + } + + @Test + public void testBuildClient() { + Client client=testSubject.buildClient(request); + assertEquals("admin", client.getUsername()); + } + + @Test + public void testRenew() { + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); + Session session2 = testSubject.newSession("admin", "admin", null); + assertNotNull(session2); + assertNotSame(session1, session2); + assertEquals(2, testSubject.getSessions().size()); + + testSubject.renew(session1.getSid()); + assertTrue(testSubject.isOpen(session1.getSid())); + assertEquals(2, testSubject.getSessions().size()); + } + + @Test + public void testCount() { + testSubject.clear(); + assertEquals(1, testSubject.countOpened(Tenant.DEFAULT_ID)); + + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); + assertTrue(testSubject.isOpen(session1.getSid())); + + assertEquals(2, testSubject.countOpened(Tenant.DEFAULT_ID)); + assertEquals(2, testSubject.countOpened()); + } + + @Test + public void testGetByClientId() { + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", client); + assertNotNull(session1); + Session session2 = testSubject.newSession("admin", "admin", null); + assertNotNull(session2); + assertNotSame(session1, session2); + assertEquals(2, testSubject.getSessions().size()); + + assertEquals(session1, testSubject.getByClientId("testid")); } @Test @@ -57,16 +189,76 @@ public void testTimeout() { int timeout = 1; conf.setProperty("default.session.timeout", "" + timeout); - SessionManager sm = SessionManager.get(); - sm.clear(); - Session session1 = sm.newSession("admin", "admin", null); - Assert.assertNotNull(session1); + testSubject.clear(); + Session session1 = testSubject.newSession("admin", "admin", null); + assertNotNull(session1); waiting(timeout); - Assert.assertFalse(sm.isOpen(session1.getSid())); + assertFalse(testSubject.isOpen(session1.getSid())); + } + + @Test + public void getSesssion() { + testSubject.clear(); + Session session = testSubject.newSession("admin", "admin", null); + when(request.getParameter(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + assertEquals(session, testSubject.getSession(request)); + + when(request.getSession(false)).thenReturn(httpSession); + when(request.getSession(false).getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + assertEquals(session, testSubject.getSession(request)); + + when(request.getSession(false).getAttribute(SessionManager.PARAM_SID)).thenReturn(null); + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + assertEquals(session, testSubject.getSession(request)); + + when(request.getParameter(SessionManager.PARAM_SID)).thenReturn(null); + when(request.getSession(false).getAttribute(SessionManager.PARAM_SID)).thenReturn(null); + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(null); + Cookie cookie = new Cookie(SessionManager.COOKIE_SID, session.getSid()); + when(request.getCookies()).thenReturn(new Cookie[] { cookie }); + assertEquals(session, testSubject.getSession(request)); + } + + @Test + public void saveSid() { + Session session = testSubject.newSession("admin", "admin", null); + when(request.getSession(false)).thenReturn(httpSession); + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + testSubject.saveSid(request, response, session.getSid()); + assertEquals(session.getSid(), testSubject.getSessionId(request)); + } + + @Test + public void removeSid() { + Session session = testSubject.newSession("admin", "admin", null); + when(request.getSession(false)).thenReturn(httpSession); + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + + testSubject.saveSid(request, response, session.getSid()); + assertEquals(session.getSid(), testSubject.getSessionId(request)); + + when(request.getAttribute(SessionManager.PARAM_SID)).thenReturn(session.getSid()); + testSubject.remove(session.getSid()); + assertNull(testSubject.getSession(request)); } + @Test + public void testCurrentSid() { + assertNull(SessionManager.getCurrentSid()); + + Session session = testSubject.newSession("admin", "admin", null); + + LDAuthenticationToken authentication=new LDAuthenticationToken("admin"); + authentication.setSid(session.getSid()); + SecurityContextHolder.getContext().setAuthentication(authentication); + + assertEquals(session.getSid(), SessionManager.getCurrentSid()); + } + private void waiting(int timeout) { synchronized (this) { try { @@ -76,4 +268,14 @@ private void waiting(int timeout) { } } } -} + + @Override + public void onSessionCreated(Session session) { + // Do nothing + } + + @Override + public void onSessionClosed(Object sid) { + // Do nothing + } +} \ No newline at end of file diff --git a/logicaldoc-core/src/test/resources/data.sql b/logicaldoc-core/src/test/resources/data.sql index 6d4ee5ec2..c783f2b7d 100644 --- a/logicaldoc-core/src/test/resources/data.sql +++ b/logicaldoc-core/src/test/resources/data.sql @@ -208,19 +208,19 @@ values (3,6,'2010-04-02 00:00:00',0,0,'c','1.3','1.3','2006-12-19 00:00:00', insert into ld_document (ld_id,ld_folderid,ld_lastmodified,ld_deleted,ld_immutable,ld_customid,ld_version,ld_date,ld_creation,ld_publisher,ld_publisherid,ld_status,ld_type,ld_lockuserid,ld_language,ld_filename,ld_filesize,ld_indexed,ld_signed,ld_creator,ld_creatorid,ld_exportstatus,ld_deleteuserid,ld_barcoded,ld_published,ld_tenantid,ld_recordversion,ld_pages,ld_stamped,ld_nature,ld_links,ld_ocrd,ld_previewpages) -values (4,6,'2010-04-04 00:00:00',1,0,'d','testDocV2','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'TXT',3,'en','pippo',122345,1,0,'',1,0,1,0,1,1,1,5,0,0,0,0,1); +values (4,6,'2010-04-04 00:00:00',1,0,'d','1.0','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'TXT',3,'en','pippo',122345,1,0,'',1,0,1,0,1,1,1,5,0,0,0,0,1); insert into ld_document (ld_id,ld_folderid,ld_lastmodified,ld_deleted,ld_immutable,ld_customid,ld_version,ld_date,ld_creation,ld_publisher,ld_publisherid,ld_status,ld_type,ld_lockuserid,ld_language,ld_filename,ld_filesize,ld_indexed,ld_signed,ld_creator,ld_creatorid,ld_exportstatus,ld_deleteuserid,ld_barcoded,ld_published,ld_tenantid,ld_recordversion,ld_pages,ld_stamped,ld_nature,ld_links,ld_ocrd,ld_previewpages) -values (5,8,'2010-04-01 00:00:00',1,0,'f','testDoc5','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'DOC',3,'en','paperino',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); +values (5,8,'2010-04-01 00:00:00',1,0,'f','1.0','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'DOC',3,'en','paperino',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); insert into ld_document (ld_id,ld_folderid,ld_lastmodified,ld_deleted,ld_immutable,ld_customid,ld_version,ld_date,ld_creation,ld_publisher,ld_publisherid,ld_status,ld_type,ld_lockuserid,ld_language,ld_filename,ld_filesize,ld_indexed,ld_signed,ld_creator,ld_creatorid,ld_exportstatus,ld_deleteuserid,ld_barcoded,ld_published,ld_tenantid,ld_recordversion,ld_pages,ld_stamped,ld_nature,ld_links,ld_ocrd,ld_previewpages) -values (6,8,'2010-04-01 00:00:00',1,0,'g','testDoc6','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'TIFF',3,'en','topolino',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); +values (6,8,'2010-04-01 00:00:00',1,0,'g','1.0','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'TIFF',3,'en','topolino',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); insert into ld_document (ld_id,ld_folderid,ld_lastmodified,ld_deleted,ld_immutable,ld_customid,ld_version,ld_date,ld_creation,ld_publisher,ld_publisherid,ld_status,ld_type,ld_lockuserid,ld_language,ld_filename,ld_filesize,ld_indexed,ld_signed,ld_creator,ld_creatorid,ld_exportstatus,ld_deleteuserid,ld_barcoded,ld_published,ld_tenantid,ld_recordversion,ld_pages,ld_stamped,ld_nature,ld_links,ld_ocrd,ld_previewpages) -values (7,6,'2010-04-01 00:00:00',0,0,'h','testDoc7','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'XML',3,'en','context.xml',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); +values (7,6,'2010-04-01 00:00:00',0,0,'h','1.0','2006-12-19 00:00:00','2006-12-19 00:00:00','myself',1,1,'XML',3,'en','context.xml',122345,1,0,'',1,0,2,0,1,1,1,5,0,0,0,0,1); insert into ld_ticket diff --git a/logicaldoc-webservice/src/test/java/com/logicaldoc/webservice/soap/endpoint/SoapAuthServiceTest.java b/logicaldoc-webservice/src/test/java/com/logicaldoc/webservice/soap/endpoint/SoapAuthServiceTest.java index a396fcd94..308959427 100644 --- a/logicaldoc-webservice/src/test/java/com/logicaldoc/webservice/soap/endpoint/SoapAuthServiceTest.java +++ b/logicaldoc-webservice/src/test/java/com/logicaldoc/webservice/soap/endpoint/SoapAuthServiceTest.java @@ -28,13 +28,13 @@ public class SoapAuthServiceTest extends AbstractWebserviceTCase { @Mock - WebServiceContext wscontext; + private WebServiceContext wscontext; @Mock - MessageContext messageContext; + private MessageContext messageContext; @Mock - HttpServletRequest httpRequest; + private HttpServletRequest httpRequest; // Instance under test private SoapAuthService soapAuthServiceImpl;