TestPageServiceImpl.java

package no.dusken.aranea.service;

import no.dusken.aranea.model.*;
import no.dusken.common.service.GenericService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;

import java.util.GregorianCalendar;
import java.util.LinkedList;
import java.util.List;

import static junit.framework.Assert.*;

/**
 * @author Marvin B. Lillehaug <lillehau@underdusken.no>
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/META-INF/integrationTest.xml"})
@TransactionConfiguration(transactionManager="transactionManager", defaultRollback=true)
@Transactional
public class TestPageServiceImpl {

    @Autowired
    private PageService pageService;

    @Autowired
    private SectionService sectionService;

    @Autowired
    private PersonService personService;

    @Autowired
    private GenericService<PageImage> pageImageService;

    @Autowired
    private ImageService imageService;

    @Autowired
    private GenericService<SectionPage> sectionPageService;

    private Section s;

    @Before
    public void onSetup(){
        List<Page> ps = pageService.getNotPublishedPages(0, 5);
        List<Image> imgs = imageService.getImages();
        List<Section> secs = sectionService.getSections(true);

        assertEquals("Database not empty", 0, ps.size());
        assertEquals("Database not empty", 0, imgs.size());
        assertEquals("Database not empty", 0, secs.size());

        Person person = new Person();
        person.setFirstname("f");
        person.setSurname("sur");
        person.setUsername("uwwwd1");
        person = personService.saveOrUpdate(person);
        assertNotNull(person);

        s = new Section();
        s.setName("Section");
        s = sectionService.saveOrUpdate(s);
        Section sub = new Section();
        sub.setParent(s);
        sub.setName("Subsection");
        sub.setUrl("sub");
        sub = sectionService.saveOrUpdate(sub);

        Page p1 = new ExtendedPage();
        p1.setTitle("tittel1");
        p1.setPublished(true);
        p1.setSummary("ingress");
        p1.setParent(s);
        p1.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
        p1.setVisibleTo(new GregorianCalendar(3900, 1, 1));
        p1.getAuthors().add(person);
        Page p = pageService.saveOrUpdate(p1);
        assertNotNull(p);
        Page p2 = new ExtendedPage();
        p2.setTitle("tittel2");
        p2.setPublished(true);
        p2.setSummary("ingress");
        p2.setParent(s);
        p2.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
        p2.setVisibleTo(new GregorianCalendar(3900, 1, 1));
        p = pageService.saveOrUpdate(p1);
        assertNotNull(p);
        Page p3 = new ExtendedPage();
        p3.setTitle("tittel3");
        p3.setPublished(true);
        p3.setSummary("ingress");
        p3.setParent(sub);
        p3.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
        p3.setVisibleTo(new GregorianCalendar(3900, 1, 1));
        p = pageService.saveOrUpdate(p1);
        assertNotNull(p);
        Page p4 = new ExtendedPage();
        p4.setTitle("tittel4");
        p4.setPublished(false);
        p4.setSummary("ingress");
        p4.setParent(s);
        p4.getAuthors().add(person);
        p4.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
        p4.setVisibleTo(new GregorianCalendar(3900, 1, 1));
        p = pageService.saveOrUpdate(p1);
        assertNotNull(p);
        Page p5 = new ExtendedPage();
        p5.setTitle("tittel5");
        p5.setPublished(false);
        p5.setSummary("ingress");
        p5.setParent(sub);
        p5.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
        p5.setVisibleTo(new GregorianCalendar(3900, 1, 1));
        p = pageService.saveOrUpdate(p1);
        assertNotNull(p);

        SectionPage sp1 = new SectionPage(s, p1, 1, "");
        SectionPage sp2 = new SectionPage(s, p2, 2, "");
        SectionPage sp3 = new SectionPage(s, p4, 3, "");
        List<SectionPage> pages = new LinkedList<SectionPage>();
        pages.add(sp1);
        pages.add(sp2);
        pages.add(sp3);
        s.setPages(pages);
        sectionService.saveOrUpdate(s);
        Section k = sectionService.getEntity(s.getID());
        assertEquals("Wrong number of pages", 3, k.getPages().size());

        SectionPage subp1 = new SectionPage(sub, p3, 1, "");
        SectionPage subp2 = new SectionPage(sub, p5, 2, "");
        List<SectionPage> subpages = new LinkedList<SectionPage>();
        subpages.add(subp1);
        subpages.add(subp2);
        sub.setPages(subpages);
        sectionService.saveOrUpdate(sub);
        Section l = sectionService.getEntity(sub.getID());
        assertEquals("Wrong number of pages", 2, l.getPages().size());
    }

    /**
     * Test that all published pages in the section is returned in the order
     * specified by their association to section.
     */
    @Test
    public void testgetSectionPagePublished(){
        List<Page> pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 2, pages.size());
        assertEquals("Wrong page as number one", "tittel1", pages.get(0).getTitle());
        assertEquals("Wrong page as number two", "tittel2", pages.get(1).getTitle());

    }

    @Test
    public void testGetSectionPageAfterVisibleInterval(){
        List<Page> pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 2, pages.size());
        for(Page p : pages){
            p.setVisibleFrom(new GregorianCalendar(1900, 1, 1));
            p.setVisibleTo(new GregorianCalendar(2000, 1, 1));
            pageService.saveOrUpdate(p);
        }
        pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 0, pages.size());
    }

    @Test
    public void testGetSectionPageBeforeVisibleInterval(){
        List<Page> pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 2, pages.size());
        for(Page p : pages){
            p.setVisibleFrom(new GregorianCalendar(2900, 1, 1));
            p.setVisibleTo(new GregorianCalendar(3000, 1, 1));
            pageService.saveOrUpdate(p);
        }
        pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 0, pages.size());
    }

    @Test
    public void testPageAssociatedInParentsParent(){
        List<Page> pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 2, pages.size());
        Section sub = sectionService.getSectionByUrl("sub", s);
        for(SectionPage sp : sub.getPages()){
            s.getPages().add(new SectionPage(s, sp.getPage(), s.getPages().size(), ""));
        }
        s = sectionService.saveOrUpdate(s);
        pages = pageService.getSectionPagePublished(5, s);
        assertEquals("Wrong number of pages returned", 3, pages.size());
    }

    @Test
    public void testgetPhotographers(){
        Person p1 = new Person();
        p1.setFirstname("f");
        p1.setSurname("sur");
        p1.setUsername("u1");
        p1 = personService.saveOrUpdate(p1);
        Image i1 = new Image();
        i1.setPhotographer(p1);
        i1.setIllustration(false);
        i1.setHash("ha");
        i1 = imageService.saveOrUpdate(i1);
        Person p2 = new Person();
        p2.setFirstname("f");
        p2.setSurname("sur");
        p2.setUsername("u2");
        p2 = personService.saveOrUpdate(p2);
        Image i2 = new Image();
        i2.setPhotographer(p2);
        i2.setIllustration(true);
        i2.setHash("hu");
        i2 = imageService.saveOrUpdate(i2);
        Page p = new ExtendedPage();
        p.setTitle("fvff");
        p.setSummary("ffdf");
        p.setParent(s);
        p = pageService.saveOrUpdate(p);
        PageImage pi1 = new PageImage();
        pi1.setImage(i1);
        pi1.setPage(p);
        pi1 = pageImageService.saveOrUpdate(pi1);
        PageImage pi2 = new PageImage();
        pi2.setImage(i2);
        pi2.setPage(p);
        pi2 = pageImageService.saveOrUpdate(pi2);

        Page dp = pageService.getEntity(p.getID());
        List<Person> photographers = pageService.getPhotographers(p);
        assertEquals("Should contain 1 person", 1, photographers.size());
        assertTrue("Should contain p1", photographers.contains(p1));
    }

    @Test
    public void testgetdrawers(){
        Person p1 = new Person();
        p1.setFirstname("f");
        p1.setSurname("sur");
        p1.setUsername("u1");
        p1 = personService.saveOrUpdate(p1);
        Image i1 = new Image();
        i1.setPhotographer(p1);
        i1.setIllustration(false);
        i1.setHash("ha");
        i1 = imageService.saveOrUpdate(i1);
        Person p2 = new Person();
        p2.setFirstname("f");
        p2.setSurname("sur");
        p2.setUsername("u2");
        p2 = personService.saveOrUpdate(p2);
        Image i2 = new Image();
        i2.setPhotographer(p2);
        i2.setIllustration(true);
        i2.setHash("hu");
        i2 = imageService.saveOrUpdate(i2);
        Page p = new ExtendedPage();
        p.setTitle("fvff");
        p.setSummary("ffdf");
        p.setParent(s);
        p = pageService.saveOrUpdate(p);
        PageImage pi1 = new PageImage();
        pi1.setImage(i1);
        pi1.setPage(p);
        pi1 = pageImageService.saveOrUpdate(pi1);
        PageImage pi2 = new PageImage();
        pi2.setImage(i2);
        pi2.setPage(p);
        pi2 = pageImageService.saveOrUpdate(pi2);

        List<Person> photographers = pageService.getDrawers(p);
        assertEquals("Should contain 1 person", 1, photographers.size());
        assertTrue("Should contain p2", photographers.contains(p2));
    }

    @Test
    public void testgetNotPublishedPages(){
        List<Page> pages = pageService.getNotPublishedPages(0, 5);
        assertEquals("Wrong number of pages", 2, pages.size());
    }

    @Test
    public void testPageWithAuthorsAreDeleted(){
        for(Page page : pageService.getPages(0, 5)){
            boolean remove = pageService.remove(page);
            assertTrue("Remove was not successful", remove);
        }
    }
}