Java tutorial
/******************************************************************************* * Copyright (c) 2010-2014 SAP AG and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * SAP AG - initial API and implementation *******************************************************************************/ package org.eclipse.skalli.core.feed.jpa; import static org.hamcrest.Matchers.*; import static org.junit.Assert.*; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.List; import java.util.UUID; import org.apache.commons.codec.digest.DigestUtils; import org.eclipse.skalli.services.feed.Entry; import org.eclipse.skalli.services.feed.FeedEntry; import org.eclipse.skalli.services.feed.FeedPersistenceService; import org.eclipse.skalli.services.feed.FeedService; import org.eclipse.skalli.testutil.BundleManager; import org.eclipse.skalli.testutil.TestUUIDs; import org.junit.Test; public class JPAFeedServiceTest { final private static UUID defaultProjectUuid = TestUUIDs.TEST_UUIDS[0]; final private static UUID allFieldsProjectUuid = TestUUIDs.TEST_UUIDS[1]; final private static UUID notPersistedProjectUuid = TestUUIDs.TEST_UUIDS[2]; final private static UUID testFindProjectUuid = TestUUIDs.TEST_UUIDS[3]; protected FeedPersistenceService getFeedPersistenceService() throws Exception { FeedPersistenceService service = BundleManager.waitService(FeedPersistenceService.class, JPAFeedPersistenceComponent.class, 1000); if (service == null) { fail(JPAFeedPersistenceComponent.class.getName() + " is not active"); } return service; } protected FeedService getFeedService() throws Exception { FeedService service = BundleManager.waitService(FeedService.class, JPAFeedComponent.class, 1000); if (service == null) { fail(JPAFeedComponent.class.getName() + " is not active"); } return service; } @Test public void testMergeWithFind() throws Exception { final String source = ("source-" + JPAFeedPersistenceServiceTest.class.getSimpleName()).substring(0, EntryJPA.SOURCE_LENGTH); final String title = "TestAllFields"; final Date testDate = new Date(1318946441120L); final String author_name = "Jon Smith"; final String author_email = "JonSmith@somehwere"; final String content_value = "test content"; final String link_title = "link title"; final String link_href = "href info"; FeedPersistenceService jPAFeedPersistenceService = getFeedPersistenceService(); FeedEntry newEntry = jPAFeedPersistenceService.createEntry(); newEntry.setSource(source); newEntry.setProjectId(allFieldsProjectUuid); newEntry.setTitle(title); newEntry.setPublished(testDate); newEntry.getAuthor().setName(author_name); newEntry.getAuthor().setEmail(author_email); newEntry.getContent().setType("text"); newEntry.getContent().setValue(content_value); newEntry.getLink().setTitle(link_title); newEntry.getLink().setHref(link_href); final String id = DigestUtils .shaHex(newEntry.getProjectId().toString() + newEntry.getTitle() + newEntry.getSource()); newEntry.setId(id); Collection<FeedEntry> entries = new ArrayList<FeedEntry>(); entries.add(newEntry); jPAFeedPersistenceService.merge(entries); FeedService jPAFeedService = getFeedService(); List<Entry> foundEntries = jPAFeedService.findEntries(allFieldsProjectUuid, 10); assertThat(foundEntries.size(), is(1)); Entry foundEntry = foundEntries.get(0); assertNotNull(foundEntry); assertThat(foundEntry.getId(), is(id)); assertThat(foundEntry.getSource(), is(source)); assertThat(foundEntry.getProjectId(), is(allFieldsProjectUuid)); assertThat(foundEntry.getTitle(), is(title)); assertThat(foundEntry.getPublished(), is(testDate)); assertThat(foundEntry.getAuthor().getName(), is(author_name)); assertThat(foundEntry.getAuthor().getEmail(), is(author_email)); assertThat(foundEntry.getContent().getType(), is("text")); assertThat(foundEntry.getContent().getValue(), is(content_value)); assertThat(foundEntry.getLink().getTitle(), is(link_title)); assertThat(foundEntry.getLink().getHref(), is(link_href)); // now update the entry and check that it updated final String newTitle = "new changed Title"; newEntry.setTitle(newTitle); entries = new ArrayList<FeedEntry>(); entries.add(newEntry); jPAFeedPersistenceService.merge(entries); foundEntries = jPAFeedService.findEntries(allFieldsProjectUuid, 10); assertThat(foundEntries.size(), is(1)); foundEntry = foundEntries.get(0); assertNotNull(foundEntry); assertThat(foundEntry.getId(), is(id)); assertThat(foundEntry.getTitle(), is(newTitle)); } @Test public void testMerge() throws Exception { FeedPersistenceService jPAFeedPersistenceService = getFeedPersistenceService(); FeedEntry entry1 = createDummyTestEntry(jPAFeedPersistenceService, "1"); FeedEntry entry2 = createDummyTestEntry(jPAFeedPersistenceService, "2"); FeedEntry entry3 = createDummyTestEntry(jPAFeedPersistenceService, "3"); Collection<FeedEntry> entries = new ArrayList<FeedEntry>(); entries.add(entry1); entries.add(entry2); jPAFeedPersistenceService.merge(entries); assertEntriesExist(new String[] { entry1.getId(), entry2.getId() }); // update again and add a third entry entries = new ArrayList<FeedEntry>(); // entries.add(entry1); // do not set all entries, only some, and check // that the old once are not deleted. entries.add(entry2); entries.add(entry3); jPAFeedPersistenceService.merge(entries); assertEntriesExist(new String[] { entry1.getId(), entry2.getId(), entry3.getId() }); } private void assertEntriesExist(String[] expectedEntryIds) throws Exception { FeedService jPAFeedService = getFeedService(); List<Entry> foundEntries = jPAFeedService.findEntries(defaultProjectUuid, expectedEntryIds.length + 100); assertThat(foundEntries.size(), is(expectedEntryIds.length)); for (String expectedId : expectedEntryIds) { assertHasEntry(foundEntries, expectedId); } } private void assertHasEntry(List<Entry> foundEntries, String expectedId) { boolean hasEntry = false; for (Entry entry : foundEntries) { if (expectedId.equals(entry.getId())) { hasEntry = true; } } assertThat(hasEntry, is(true)); } private FeedEntry createDummyTestEntry(FeedPersistenceService s, String title) { FeedEntry newEntry = s.createEntry(); newEntry.setSource(("source-" + JPAFeedPersistenceServiceTest.class.getSimpleName()).substring(0, EntryJPA.SOURCE_LENGTH)); newEntry.setProjectId(defaultProjectUuid); newEntry.setTitle(title); newEntry.setPublished(new Date()); updateId(newEntry); return newEntry; } @Test public void testFindCalls() throws Exception { final Date testDate = new Date(1318946441120L); FeedPersistenceService jPAFeedPersistenceService = getFeedPersistenceService(); FeedEntry e1 = jPAFeedPersistenceService.createEntry(); e1.setSource("source-a"); e1.setProjectId(testFindProjectUuid); e1.setTitle("t1"); e1.setPublished(testDate); updateId(e1); FeedEntry e2 = jPAFeedPersistenceService.createEntry(); e2.setSource("source-a"); e2.setProjectId(testFindProjectUuid); e2.setTitle("t2"); e2.setPublished(new Date(testDate.getTime() + 1)); updateId(e2); FeedEntry e3 = jPAFeedPersistenceService.createEntry(); e3.setSource("source-a"); e3.setProjectId(testFindProjectUuid); e3.setTitle("t3"); e3.setPublished(new Date(testDate.getTime() + 2)); updateId(e3); FeedEntry e4 = jPAFeedPersistenceService.createEntry(); e4.setSource("source-b"); e4.setProjectId(testFindProjectUuid); e4.setTitle("t4"); e4.setPublished(new Date(testDate.getTime() + 3)); updateId(e4); Collection<FeedEntry> entries = new ArrayList<FeedEntry>(); entries.add(e1); entries.add(e2); entries.add(e3); entries.add(e4); jPAFeedPersistenceService.merge(entries); // findEntries: check that the maxResult parameter of findEnties works: FeedService jPAFeedService = getFeedService(); for (int maxResults = 0; maxResults < 10; maxResults++) { List<Entry> foundEntries = jPAFeedService.findEntries(testFindProjectUuid, maxResults); assertThat(foundEntries.size(), is(Math.min(maxResults, 4))); if (maxResults > 0) { // check that the entries are ordered desc by published for (int i = 1; i < foundEntries.size(); i++) { Date date0 = foundEntries.get(i - 1).getPublished(); Date date1 = foundEntries.get(i).getPublished(); assertTrue("expected: " + date0.getTime() + ">" + date1.getTime(), date0.compareTo(date1) > 0); } } } // findEntries: check find with 1 source List<Entry> foundEntries = jPAFeedService.findEntries(testFindProjectUuid, Collections.singleton("source-a"), 10); assertThat(foundEntries.size(), is(3)); for (Entry entry : foundEntries) { assertThat(entry.getSource(), is("source-a")); } // findEntries:: check find with 2 different sources Collection<String> sources = new ArrayList<String>(); sources.add("source-a"); sources.add("source-b"); foundEntries = jPAFeedService.findEntries(testFindProjectUuid, sources, 10); assertThat(foundEntries.size(), is(4)); for (Entry entry : foundEntries) { assertThat(entry.getSource(), isIn(sources)); } // findEntries: check find with 1 sources and second one not existing sources = new ArrayList<String>(); sources.add("source-a"); sources.add("notExistingSource"); foundEntries = jPAFeedService.findEntries(testFindProjectUuid, sources, 10); assertThat(foundEntries.size(), is(3)); for (Entry entry : foundEntries) { assertThat(entry.getSource(), is("source-a")); } // findEntries: check find with 1 sources not persisted source sources = new ArrayList<String>(); sources.add("notExistingSource"); foundEntries = jPAFeedService.findEntries(testFindProjectUuid, sources, 10); assertThat(foundEntries.size(), is(0)); // findSources List<String> foundSources = jPAFeedService.findSources(testFindProjectUuid); assertThat(foundSources.size(), is(2)); // sources are expected to be order by there name assertThat(foundSources.get(0), is("source-a")); assertThat(foundSources.get(1), is("source-b")); } private void updateId(FeedEntry newEntry) { // in this test we calculate the id via project, title and source. String id = newEntry.getProjectId().toString() + newEntry.getTitle() + newEntry.getSource(); newEntry.setId(DigestUtils.shaHex(id)); } @Test public void testfindEntriesIllegalParameters() throws Exception { FeedService jPAFeedService = getFeedService(); try { jPAFeedService.findEntries(null, 4711); fail("IllegalArgumentException was expected."); } catch (IllegalArgumentException e) { assertThat(e.getMessage(), containsString("projectId")); } try { jPAFeedService.findEntries(null, Collections.EMPTY_LIST, 4711); fail("IllegalArgumentException was expected."); } catch (IllegalArgumentException e) { assertThat(e.getMessage(), containsString("projectId")); } } @Test public void testfindEmptyResult() throws Exception { FeedService jPAFeedService = getFeedService(); assertThat(jPAFeedService.findEntries(defaultProjectUuid, Collections.EMPTY_LIST, 4711).size(), is(0)); assertThat(jPAFeedService.findEntries(defaultProjectUuid, Collections.EMPTY_LIST, FeedService.SELECT_ALL) .size(), is(0)); assertThat(jPAFeedService.findEntries(defaultProjectUuid, Collections.EMPTY_LIST, -4711).size(), is(0)); assertThat(jPAFeedService.findEntries(defaultProjectUuid, null, 0).size(), is(0)); assertThat(jPAFeedService.findEntries(notPersistedProjectUuid, 10).size(), is(0)); } @Test public void testFindSourcesIllegalParameters() throws Exception { FeedService jPAFeedService = getFeedService(); try { jPAFeedService.findSources(null); fail("IllegalArgumentException was expected."); } catch (IllegalArgumentException e) { assertThat(e.getMessage(), containsString("projectId")); } } }