CombinedMasterTest.java example

Explorer
OG-Platform-master
- projects
- sesame
package com.opengamma.master;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.mockito.Mockito;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.opengamma.id.ObjectId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
import com.opengamma.master.CombinedMaster.SearchCallback;
import com.opengamma.master.CombinedMaster.SearchStrategy;
import com.opengamma.master.holiday.HolidayDocument;
import com.opengamma.master.holiday.HolidayMaster;
import com.opengamma.master.holiday.HolidaySearchRequest;
import com.opengamma.master.holiday.HolidaySearchResult;
import com.opengamma.util.paging.Paging;
import com.opengamma.util.paging.PagingRequest;
import com.opengamma.util.test.TestGroup;

@Test(groups = TestGroup.UNIT)
public class CombinedMasterTest {

  private HolidayMaster m1;
  private HolidayMaster m2;
  
  private ObjectId o1;
  private ObjectId o2;
  private UniqueId u1;
  private UniqueId u2;
  
  private HolidayDocument d1;
  private HolidayDocument d2;
  
  private CombinedMaster<HolidayDocument, HolidayMaster> cMaster;
  
  @BeforeMethod
  public void beforeMethod() {
    m1 = mock(HolidayMaster.class);
    m2 = mock(HolidayMaster.class);
    o1 = ObjectId.of("TestScheme", "123");
    o2 = ObjectId.of("TestScheme2", "234");
    u1 = UniqueId.of(o1, "v123");
    u2 = UniqueId.of(o2, "v234");
    d1 = mock(HolidayDocument.class);
    d2 = mock(HolidayDocument.class);
    when(d1.getUniqueId()).thenReturn(u1);
    when(d1.getObjectId()).thenReturn(o1);
    cMaster = new CombinedMaster<HolidayDocument, HolidayMaster>(ImmutableList.of(m1, m2)) {};
  }
  
  @Test
  public void add() {
    when(m1.add(d1)).thenReturn(d1);
    
    cMaster.add(d1);
    
    verify(m1).add(d1);
  }

  @Test
  public void addVersionToM1() {
    //test multiple invocations here
    when(m1.replaceVersions(o1, Collections.singletonList(d1))).thenReturn(Collections.singletonList(u1));
    when(m1.replaceVersions(o1, Collections.singletonList(d1))).thenReturn(Collections.singletonList(u1));
    
    cMaster.replaceVersions(o1, Collections.singletonList(d1));
    cMaster.replaceVersions(o1, Collections.singletonList(d1));
    
    verify(m1, times(2)).replaceVersions(o1, Collections.singletonList(d1));
  }

  @Test
  public void addVersionToM2() {
    
    when(m1.replaceVersions(o1, Collections.singletonList(d1))).thenThrow(new IllegalArgumentException());
    when(m2.replaceVersions(o1, Collections.singletonList(d1))).thenReturn(Collections.singletonList(u1));

    cMaster.replaceVersions(o1, Collections.singletonList(d1));
    
    verify(m1).replaceVersions(o1, Collections.singletonList(d1));
  }
  
  @Test(expectedExceptions= {IllegalArgumentException.class})
  public void addVersionException() {
    
    when(m1.replaceVersions(o1, Collections.singletonList(d1))).thenThrow(new IllegalArgumentException());
    when(m2.replaceVersions(o1, Collections.singletonList(d1))).thenThrow(new IllegalArgumentException());

    cMaster.replaceVersions(o1, Collections.singletonList(d1));
  }

  @Test
  public void applyPaging() {
    HolidayDocument m1h1 = holidayDocWithId("m1", "1");
    HolidayDocument m1h2 = holidayDocWithId("m1", "2");
    HolidayDocument m1h3 = holidayDocWithId("m1", "3");
    HolidayDocument m1h4 = holidayDocWithId("m1", "4");
    HolidaySearchResult sr;
    sr = new HolidaySearchResult(ImmutableList.of(m1h1, m1h2, m1h3, m1h4));
    
    PagingRequest ofIndex ;
    ofIndex = PagingRequest.ofIndex(1, 3);
    
    cMaster.applyPaging(sr, ofIndex);
    
    assertEquals(Paging.of(ofIndex, 4), sr.getPaging());
    assertEquals(ImmutableList.of(m1h2, m1h3, m1h4), sr.getDocuments());

    sr = new HolidaySearchResult(ImmutableList.of(m1h1, m1h2, m1h3, m1h4));
    
    ofIndex = PagingRequest.ofIndex(100, 103);
    
    cMaster.applyPaging(sr, ofIndex);
    
    assertEquals(Paging.of(ofIndex, 4), sr.getPaging());
    assertEquals(ImmutableList.of(), sr.getDocuments());

  }

  @Test
  public void correct() {
    //test multiple invocations here
    cMaster.correct(d1);
    cMaster.correct(d1);
    
    verify(m1, times(2)).correct(d1);
  }

  @Test
  public void getUniqueId() {
    //test multiple invocations here
    when(m1.get(u1)).thenReturn(d1);
    
    cMaster.get(u1);
    cMaster.get(u1);
    
    verify(m1, times(2)).get(u1);
  }

  @Test
  public void getObjectIdentifiableVersionCorrection() {
    VersionCorrection vc = VersionCorrection.LATEST;
    //test multiple invocations here
    when(m1.get(o1, vc)).thenReturn(d1);
    
    cMaster.get(o1, vc);
    cMaster.get(o1, vc);
    
    verify(m1, times(2)).get(o1, vc);
  }

  @Test
  public void getMasterList() {
    assertEquals(ImmutableList.of(m1, m2), cMaster.getMasterList());
  }

  @Test
  public void remove() {
    //test multiple invocations here
    cMaster.remove(d1);
    cMaster.remove(d1);
    
    verify(m1, times(2)).remove(d1);
  }

  @Test
  public void removeVersion() {
    cMaster.removeVersion(u1);
    cMaster.removeVersion(u1);
    
    verify(m1, times(2)).replaceVersion(u1, Collections.<HolidayDocument>emptyList());
  }

  @Test
  public void replaceAllVersions() {
    cMaster.replaceAllVersions(o1, Lists.newArrayList(d1));
    cMaster.replaceAllVersions(o1, Lists.newArrayList(d1));
    
    verify(m1, times(2)).replaceAllVersions(o1, Lists.newArrayList(d1));
  }

  @Test
  public void replaceVersionUniqueIdListD() {
    cMaster.replaceVersion(u1, Lists.newArrayList(d1));
    cMaster.replaceVersion(u1, Lists.newArrayList(d1));
    
    verify(m1, times(2)).replaceVersion(u1, Lists.newArrayList(d1));
    
  }

  @Test
  public void replaceVersionD() {
    cMaster.replaceVersion(d1);
    cMaster.replaceVersion(d1);
    
    verify(m1, times(2)).replaceVersion(u1, Collections.singletonList(d1));
  }

  @Test
  public void replaceVersions() {
    cMaster.replaceVersions(o1, Collections.singletonList(d1));
    cMaster.replaceVersions(o1, Collections.singletonList(d1));
    
    verify(m1, times(2)).replaceVersions(o1, Collections.singletonList(d1));

  }

  @Test
  public void search() {
    
    HolidayDocument m1h1 = holidayDocWithId("m1", "1");
    HolidayDocument m1h2 = holidayDocWithId("m1", "2");
    HolidayDocument m1h3 = holidayDocWithId("m1", "3");
    HolidayDocument m1h4 = holidayDocWithId("m1", "4");

    HolidayDocument m2h3 = holidayDocWithId("m2", "3");
    HolidayDocument m2h4 = holidayDocWithId("m2", "4");
    HolidayDocument m2h5 = holidayDocWithId("m2", "5");
    HolidayDocument m2h6 = holidayDocWithId("m2", "6");
    final HolidayDocument m2h7 = holidayDocWithId("m2", "7");

    HolidaySearchResult m1Result = new HolidaySearchResult(Lists.newArrayList(m1h1, m1h2, m1h2, m1h3, m1h4, m1h4));
    HolidaySearchResult m2Result = new HolidaySearchResult(Lists.newArrayList(m2h3, m2h4, m2h5, m2h6, m2h7));
    
    final List<HolidayDocument> resultList = Lists.newArrayList();
    
    @SuppressWarnings("unchecked")
    final SearchCallback<HolidayDocument, HolidayMaster> cbDelegate = mock(SearchCallback.class);
    
    cMaster.search(Lists.newArrayList(m1Result, m2Result, null), new SearchCallback<HolidayDocument, HolidayMaster>() {

      @Override
      public int compare(HolidayDocument arg0, HolidayDocument arg1) {
        return arg0.getUniqueId().getValue().compareTo(arg1.getUniqueId().getValue());
      }

      @Override
      public boolean include(HolidayDocument document) {
        return !m2h7.equals(document);
      }

      @Override
      public void accept(HolidayDocument document, HolidayMaster master, boolean masterUnique, boolean clientUnique) {
        cbDelegate.accept(document, master, masterUnique, clientUnique);
        resultList.add(document);
      }
    });
    
    verify(cbDelegate).accept(m1h1, m1, true, true);
    verify(cbDelegate, times(2)).accept(m1h2, m1, false, true);
    verify(cbDelegate).accept(m1h3, m1, true, false);
    verify(cbDelegate).accept(m2h3, m2, true, false);
    verify(cbDelegate, times(2)).accept(m1h4, m1, false, false);
    verify(cbDelegate).accept(m2h4, m2, true, false);
    verify(cbDelegate).accept(m2h5, m2, true, true);
    verify(cbDelegate).accept(m2h6, m2, true, true);
    verifyNoMoreInteractions(cbDelegate);
    
    
    ArrayList<HolidayDocument> sortedResultList = Lists.newArrayList(resultList);
    Collections.sort(sortedResultList, cbDelegate);
    assertEquals(sortedResultList, resultList);

    
  }

  private HolidayDocument holidayDocWithId(String scheme, String id) {
    HolidayDocument holidayDocument = new HolidayDocument();
    holidayDocument.setUniqueId(UniqueId.of(scheme, id));
    return holidayDocument;
  }
  
  @Test
  public void get() {
    ArrayList<UniqueId> getList = Lists.newArrayList(u1, u2);
    
    when(m1.get(u2)).thenThrow(new IllegalArgumentException());
    
    cMaster.get(getList);
    cMaster.get(getList);
    
    verify(m1, times(2)).get(u1);
    verify(m2, times(2)).get(u2);
  }

  @Test
  public void update() {
    //test multiple invocations here
    cMaster.update(d1);
    cMaster.update(d1);
    
    verify(m1, times(2)).update(d1);

  }
  
  
  @Test
  public void pagedSearchEmpty() {
    PagingRequest pr = PagingRequest.ALL;
    List<HolidayDocument> m1Result = Lists.newArrayList();
    List<HolidayDocument> m2Result = Lists.newArrayList();
    
    List<HolidayDocument> result = runPagedSearch(pr, m1Result, 0, m2Result, 0);
    
    assertTrue(result.isEmpty());
  }

  @Test
  public void pagedSearchOneElement() {
    PagingRequest pr = PagingRequest.ALL;
    List<HolidayDocument> singleton = Lists.newArrayList(d1);
    List<HolidayDocument> empty = Lists.newArrayList();
    
    List<HolidayDocument> result = runPagedSearch(pr, singleton, 1, empty, 0);
    assertEquals(1, result.size());
  
    List<HolidayDocument> result2 = runPagedSearch(pr, empty, 0, singleton, 1);
    assertEquals(1, result2.size());

  }

  @Test
  public void pagedSearchTwoElements() {
    PagingRequest pr;
    List<HolidayDocument> singleton = Lists.newArrayList(d1);
    List<HolidayDocument> empty = Lists.newArrayList();
    
    pr = PagingRequest.ofIndex(0, 1);
    List<HolidayDocument> result2 = runPagedSearch(pr, singleton, 1, singleton, 1);
    assertEquals(1, result2.size());
    verifyNoMoreInteractions(m2);
  
    pr = PagingRequest.ALL;
    List<HolidayDocument> result = runPagedSearch(pr, singleton, 1, singleton, 1);
    assertEquals(2, result.size());
  
  
    pr = PagingRequest.ofIndex(1, 1);
    List<HolidayDocument> result3 = runPagedSearch(pr, empty, 1, singleton, 1);
    assertEquals(1, result3.size());
  }

  @Test
  public void pagedSearchMultiple() {
    PagingRequest pr = PagingRequest.ofIndex(2, 2);
    List<HolidayDocument> m1Result = Lists.newArrayList(d1);
    List<HolidayDocument> m2Result = Lists.newArrayList(d2);
    List<HolidayDocument> expected = Lists.newArrayList(d1, d2);
    
    List<HolidayDocument> result = runPagedSearch(pr, m1Result, 3, m2Result, 1);
    
    assertEquals(2, result.size());
    
    assertEquals(expected, result);
    
  }

  @Test
  public void pagedSearchOnlyFirst() {
    List<HolidayDocument> m2Result = Lists.newArrayList();
    List<HolidayDocument> result ;
    
    result = runPagedSearch(PagingRequest.ofIndex(0, 2), Lists.newArrayList(d1, d1), 3, m2Result, 0);
    assertEquals(2, result.size());
    
    result = runPagedSearch(PagingRequest.ofIndex(1, 2), Lists.newArrayList(d1, d1), 3, m2Result, 0);
    assertEquals(2, result.size());
    
    result = runPagedSearch(PagingRequest.ofIndex(0, 3), Lists.newArrayList(d1, d1, d1), 3, m2Result, 0);
    assertEquals(3, result.size());
    
    verifyNoMoreInteractions(m2);
    
  }
  
  private List<HolidayDocument> runPagedSearch(PagingRequest pr, List<HolidayDocument> m1Result, int m1Total, List<HolidayDocument> m2Result, int m2Total) {
    HolidaySearchResult result = new HolidaySearchResult();
    HolidaySearchRequest searchRequest = new HolidaySearchRequest();
    searchRequest.setPagingRequest(pr);
    HolidaySearchResult m1SearchResult = new HolidaySearchResult();
    m1SearchResult.setDocuments(m1Result);
    m1SearchResult.setPaging(Paging.of(PagingRequest.ofIndex(0, m1Result.size()), m1Total));
    HolidaySearchResult m2SearchResult = new HolidaySearchResult();
    m2SearchResult.setPaging(Paging.of(PagingRequest.ofIndex(0, m2Result.size()), m2Total));
    m2SearchResult.setDocuments(m2Result);
    
    when(m1.search(Mockito.<HolidaySearchRequest>any())).thenReturn(m1SearchResult);
    when(m2.search(Mockito.<HolidaySearchRequest>any())).thenReturn(m2SearchResult);
    
    cMaster.pagedSearch(new SearchStrategy<HolidayDocument, HolidayMaster, HolidaySearchRequest>() {

      @Override
      public HolidaySearchResult search(HolidayMaster master, HolidaySearchRequest searchRequest) {
        return master.search(searchRequest);
      }
    }, result, searchRequest);
    
    return result.getDocuments();
  }
}