SourceNacJudgmentExtractorTest.java

package pl.edu.icm.saos.importer.notapi.nationalappealchamber.judgment.process;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;

import java.util.List;

import org.hamcrest.Matchers;
import org.joda.time.DateTime;
import org.joda.time.LocalDate;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import pl.edu.icm.saos.importer.common.JudgmentMeansOfAppealCreator;
import pl.edu.icm.saos.importer.common.JudgmentResultCreator;
import pl.edu.icm.saos.importer.common.correction.ImportCorrectionList;
import pl.edu.icm.saos.importer.notapi.common.SourceJudgeExtractorHelper;
import pl.edu.icm.saos.importer.notapi.common.SourceJudgment.Source;
import pl.edu.icm.saos.importer.notapi.nationalappealchamber.judgment.json.SourceNacJudgment;
import pl.edu.icm.saos.persistence.model.CourtCase;
import pl.edu.icm.saos.persistence.model.CourtType;
import pl.edu.icm.saos.persistence.model.Judge;
import pl.edu.icm.saos.persistence.model.JudgmentResult;
import pl.edu.icm.saos.persistence.model.JudgmentTextContent;
import pl.edu.icm.saos.persistence.model.MeansOfAppeal;
import pl.edu.icm.saos.persistence.model.Judgment.JudgmentType;
import pl.edu.icm.saos.persistence.model.JudgmentReferencedRegulation;
import pl.edu.icm.saos.persistence.model.NationalAppealChamberJudgment;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;

/**
 * @author madryk
 */
@RunWith(MockitoJUnitRunner.class)
public class SourceNacJudgmentExtractorTest {

    private SourceNacJudgmentExtractor judgmentExtractor = new SourceNacJudgmentExtractor();
    
    @Mock
    private JudgmentMeansOfAppealCreator judgmentMeansOfAppealCreator;
    
    @Mock
    private JudgmentResultCreator judgmentResultCreator;
    
    @Mock
    private SourceJudgeExtractorHelper sourceJudgeExtractorHelper;
    
    
    private SourceNacJudgment sJudgment = new SourceNacJudgment();
    
    private ImportCorrectionList correctionList = new ImportCorrectionList();
    
    
    @Before
    public void setUp() {
        judgmentExtractor.setJudgmentMeansOfAppealCreator(judgmentMeansOfAppealCreator);
        judgmentExtractor.setJudgmentResultCreator(judgmentResultCreator);
        judgmentExtractor.setSourceJudgeExtractorHelper(sourceJudgeExtractorHelper);
    }
    
    
    //------------------------ TESTS --------------------------
    
    @Test
    public void createNewJudgment() {
        // execute
        NationalAppealChamberJudgment nacJudgment = judgmentExtractor.createNewJudgment();
        
        // assert
        assertNotNull(nacJudgment);
    }
    
    @Test
    public void extractCourtCases() {
        
        // given
        sJudgment.setCaseNumbers(Lists.newArrayList("CASE 211w/121", "CASE 231a/231"));
        
        // execute
        List<CourtCase> courtCases = judgmentExtractor.extractCourtCases(sJudgment, correctionList);
        
        // assert
        assertEquals(2, courtCases.size());
        assertEquals(sJudgment.getCaseNumbers().get(0), courtCases.get(0).getCaseNumber());
        assertEquals(sJudgment.getCaseNumbers().get(1), courtCases.get(1).getCaseNumber());
        
    }
    
    @Test
    public void extractCourtReporters() {
        
        // given
        sJudgment.setCourtReporters(Lists.newArrayList("Jan Kowalski", "Adam Nowak"));
        
        // execute
        List<String> courtReporters = judgmentExtractor.extractCourtReporters(sJudgment, correctionList);
        
        // assert
        assertEquals(2, courtReporters.size());
        assertEquals(sJudgment.getCourtReporters().get(0), courtReporters.get(0));
        assertEquals(sJudgment.getCourtReporters().get(1), courtReporters.get(1));
    }
    

      
    @Test
    public void extractDecision() {
        
        // execute
        String decision = judgmentExtractor.extractDecision(sJudgment, correctionList);
        
        // assert
        assertNull(decision);
        
    }
    
    
    @Test
    public void extractPublisher() {
        
        // execute
        String publisher = judgmentExtractor.extractPublisher(sJudgment, correctionList);
        
        // assert
        assertNull(publisher);
        
    }
    
    
    @Test
    public void extractReviser() {
        
        // execute
        String reviser = judgmentExtractor.extractReviser(sJudgment, correctionList);
        
        // assert
        assertNull(reviser);
        
    }
    
    
    @Test
    public void extractSourceJudgmentId() {
        
        // given
        sJudgment.setSource(new Source());
        sJudgment.getSource().setSourceJudgmentId("1221212121222 ");
        
        // execute
        String sourceJudgmentId = judgmentExtractor.extractSourceJudgmentId(sJudgment, correctionList);
        
        // assert
        assertEquals(sJudgment.getSource().getSourceJudgmentId(), sourceJudgmentId);
        
    }
    
    
    @Test
    public void extractSourceJudgmentUrl() {
        
        // given
        sJudgment.setSource(new Source());
        sJudgment.getSource().setSourceJudgmentUrl("www.www.pl");
        
        // execute
        String sourceJudgmentUrl = judgmentExtractor.extractSourceJudgmentUrl(sJudgment, correctionList);
        
        
        // assert
        assertEquals(sJudgment.getSource().getSourceJudgmentUrl(), sourceJudgmentUrl);
        
    }
    
    
    @Test
    public void extractSummary() {
        
        // execute
        String summary = judgmentExtractor.extractSummary(sJudgment, correctionList);
        
        // assert
        assertNull(summary);
        
    }

    
    @Test
    public void extractTextContent() {
        
        // given
        sJudgment.setTextContent("sdlsdklskd <sbfmd ck dkjcd kjcdkj cndjc\n fdfdf");
        
        // execute
        JudgmentTextContent textContent = judgmentExtractor.extractTextContent(sJudgment, correctionList);
        
        // assert
        assertEquals(sJudgment.getTextContent(), textContent.getRawTextContent());
        
    }
    
    
    @Test
    public void extractJudgmentDate() {
        
        // given
        sJudgment.setJudgmentDate(new LocalDate());
        
        // execute
        LocalDate judgmentDate = judgmentExtractor.extractJudgmentDate(sJudgment, correctionList);
        
        // assert
        assertEquals(sJudgment.getJudgmentDate(), judgmentDate);
        
    }
    
    
    @Test
    public void extractPublicationDate() {
        
        // execute
        DateTime publicationDate = judgmentExtractor.extractPublicationDate(sJudgment, correctionList);
        
        // assert
        assertNull(publicationDate);
        
    }
    
    @Test
    public void extractJudges() {
        
        // given
        Judge judge = new Judge("Jan Kowalski");
        List<Judge> judges = ImmutableList.of(judge);
        
        when(sourceJudgeExtractorHelper.extractJudges(sJudgment, correctionList)).thenReturn(judges);
        
        
        // execute
        List<Judge> returnedJudges = judgmentExtractor.extractJudges(sJudgment, correctionList);
        
        
        // assert
        assertTrue(returnedJudges == judges);
    }

    
    @Test
    public void extractJudgmentType() {
        
        // given
        sJudgment.setJudgmentType("SENTENCE");
        
        // execute
        JudgmentType retJudgmentType = judgmentExtractor.extractJudgmentType(sJudgment, correctionList);
        
        // assert
        assertEquals(JudgmentType.SENTENCE, retJudgmentType);
        
    }
    
    
    @Test
    public void extractLegalBases() {
        
        // execute
        List<String> legalBases = judgmentExtractor.extractLegalBases(sJudgment, correctionList);
        
        // assert
        assertThat(legalBases, is(empty()));
        
    }
    
    
    @Test
    public void extractReferencedRegulations() {
        
        // execute
        List<JudgmentReferencedRegulation> referencedRegulations = judgmentExtractor.extractReferencedRegulations(sJudgment, correctionList);
        
        // assert
        assertThat(referencedRegulations, is(empty()));
    }
    
    
    @Test
    public void extractReceiptDate() {
        // given
        LocalDate receiptDate = new LocalDate();
        sJudgment.setReceiptDate(receiptDate);
        
        // execute
        LocalDate retReceiptDate = judgmentExtractor.extractReceiptDate(sJudgment, correctionList);
        
        // assert
        assertEquals(receiptDate, retReceiptDate);
    }
    
    @Test
    public void extractLowerCourtJudgments() {
        // given
        List<String> lowerCourtJudgments = Lists.newArrayList("first", "second");
        sJudgment.setLowerCourtJudgments(lowerCourtJudgments);
        
        // execute
        List<String> retLowerCourtJudgments = judgmentExtractor.extractLowerCourtJudgments(sJudgment, correctionList);
        
        // assert
        assertThat(retLowerCourtJudgments, Matchers.contains(lowerCourtJudgments.get(0), lowerCourtJudgments.get(1)));
    }
    
    @Test
    public void extractMeansOfAppeal() {
        // given
        String meansOfAppealString = "meansOfAppeal";
        MeansOfAppeal meansOfAppeal = new MeansOfAppeal(CourtType.NATIONAL_APPEAL_CHAMBER, meansOfAppealString);
        sJudgment.setMeansOfAppeal(meansOfAppealString);
        
        when(judgmentMeansOfAppealCreator.fetchOrCreateMeansOfAppeal(CourtType.NATIONAL_APPEAL_CHAMBER, meansOfAppealString)).thenReturn(meansOfAppeal);
        
        
        // execute
        MeansOfAppeal retMeansOfAppeal = judgmentExtractor.extractMeansOfAppeal(sJudgment, correctionList);
        
        
        // assert
        assertTrue(meansOfAppeal == retMeansOfAppeal);
    }
    
    @Test
    public void extractJudgmentResult() {
        // given
        String judgmentResultString = "judgmentResult";
        JudgmentResult judgmentResult = new JudgmentResult(CourtType.NATIONAL_APPEAL_CHAMBER, judgmentResultString);
        sJudgment.setJudgmentResult(judgmentResultString);
        
        when(judgmentResultCreator.fetchOrCreateJudgmentResult(CourtType.NATIONAL_APPEAL_CHAMBER, judgmentResultString)).thenReturn(judgmentResult);
        
        
        // execute
        JudgmentResult retJudgmentResult = judgmentExtractor.extractJudgmentResult(sJudgment, correctionList);
        
        
        // assert
        assertTrue(judgmentResult == retJudgmentResult);
    }
    
    
}