QuerySplittingMasterTest.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.master.impl;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertSame;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

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

import com.google.common.collect.ImmutableMap;
import com.opengamma.core.change.ChangeManager;
import com.opengamma.id.ObjectId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
import com.opengamma.master.AbstractChangeProvidingMaster;
import com.opengamma.master.AbstractDocument;
import com.opengamma.util.test.TestGroup;

/**
 * Tests the {@link AbstractQuerySplittingMaster} class.
 */
@Test(groups = TestGroup.UNIT)
@SuppressWarnings({"rawtypes", "unchecked" })
public class QuerySplittingMasterTest {

  private AbstractQuerySplittingMaster instance(final AbstractChangeProvidingMaster underlying) {
    return new AbstractQuerySplittingMaster(underlying) {
    };
  }

  public void testGet_uid() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.get(UniqueId.of("Foo", "Bar"))).thenReturn(doc);
    assertSame(instance.get(UniqueId.of("Foo", "Bar")), doc);
  }

  public void testGet_oid() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.get(ObjectId.of("Foo", "Bar"), VersionCorrection.LATEST)).thenReturn(doc);
    assertSame(instance.get(ObjectId.of("Foo", "Bar"), VersionCorrection.LATEST), doc);
  }

  public void testGet_multiple_uid_disabled() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final Map<UniqueId, AbstractDocument> docs = Collections.singletonMap(UniqueId.of("Foo", "Bar"), Mockito.mock(AbstractDocument.class));
    Mockito.when(mock.get(Collections.singleton(UniqueId.of("Foo", "Bar")))).thenReturn(docs);
    assertEquals(instance.getMaxGetRequest(), 0);
    assertSame(instance.get(Collections.singleton(UniqueId.of("Foo", "Bar"))), docs);
  }

  public void testGet_multiple_uid_small() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final Map<UniqueId, AbstractDocument> docs = Collections.singletonMap(UniqueId.of("Foo", "Bar"), Mockito.mock(AbstractDocument.class));
    Mockito.when(mock.get(Collections.singleton(UniqueId.of("Foo", "Bar")))).thenReturn(docs);
    instance.setMaxGetRequest(1);
    assertSame(instance.get(Collections.singleton(UniqueId.of("Foo", "Bar"))), docs);
  }

  public void testGet_multiple_uid_large() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final Map<UniqueId, AbstractDocument> docs1 = ImmutableMap.of(UniqueId.of("Test", "1"), Mockito.mock(AbstractDocument.class));
    final Map<UniqueId, AbstractDocument> docs2 = ImmutableMap.of(UniqueId.of("Test", "2"), Mockito.mock(AbstractDocument.class), UniqueId.of("Test", "3"), Mockito.mock(AbstractDocument.class));
    final Map<UniqueId, AbstractDocument> docs3 = ImmutableMap.of(UniqueId.of("Test", "4"), Mockito.mock(AbstractDocument.class), UniqueId.of("Test", "5"), Mockito.mock(AbstractDocument.class));
    Mockito.when(mock.get(Arrays.asList(UniqueId.of("Test", "1")))).thenReturn(docs1);
    Mockito.when(mock.get(Arrays.asList(UniqueId.of("Test", "2"), UniqueId.of("Test", "3")))).thenReturn(docs2);
    Mockito.when(mock.get(Arrays.asList(UniqueId.of("Test", "4"), UniqueId.of("Test", "5")))).thenReturn(docs3);
    instance.setMaxGetRequest(2);
    final Map<UniqueId, AbstractDocument> docs = new HashMap<UniqueId, AbstractDocument>();
    docs.putAll(docs1);
    docs.putAll(docs2);
    docs.putAll(docs3);
    assertEquals(instance.get(Arrays.asList(UniqueId.of("Test", "1"), UniqueId.of("Test", "2"), UniqueId.of("Test", "3"), UniqueId.of("Test", "4"), UniqueId.of("Test", "5"))), docs);
  }

  public void testAdd() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc1 = Mockito.mock(AbstractDocument.class);
    final AbstractDocument doc2 = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.add(doc1)).thenReturn(doc2);
    assertSame(instance.add(doc1), doc2);
  }

  public void testUpdate() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc1 = Mockito.mock(AbstractDocument.class);
    final AbstractDocument doc2 = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.update(doc1)).thenReturn(doc2);
    assertSame(instance.update(doc1), doc2);
  }

  public void testRemove() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    instance.remove(ObjectId.of("Foo", "Bar"));
    Mockito.verify(mock, Mockito.only()).remove(ObjectId.of("Foo", "Bar"));
  }

  public void testCorrect() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc1 = Mockito.mock(AbstractDocument.class);
    final AbstractDocument doc2 = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.correct(doc1)).thenReturn(doc2);
    assertSame(instance.correct(doc1), doc2);
  }

  public void testReplaceVersion_uid() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    Mockito.when(mock.replaceVersion(UniqueId.of("Foo", "Bar"), Collections.emptyList())).thenReturn(Collections.emptyList());
    assertEquals(instance.replaceVersion(UniqueId.of("Foo", "Bar"), Collections.emptyList()), Collections.emptyList());
  }

  public void testReplaceAllVersions() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    Mockito.when(mock.replaceAllVersions(ObjectId.of("Foo", "Bar"), Collections.emptyList())).thenReturn(Collections.emptyList());
    assertEquals(instance.replaceAllVersions(ObjectId.of("Foo", "Bar"), Collections.emptyList()), Collections.emptyList());
  }

  public void testReplaceVersions() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    Mockito.when(mock.replaceVersions(ObjectId.of("Foo", "Bar"), Collections.emptyList())).thenReturn(Collections.emptyList());
    assertEquals(instance.replaceVersions(ObjectId.of("Foo", "Bar"), Collections.emptyList()), Collections.emptyList());
  }

  public void testReplaceVersion_doc() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.replaceVersion(doc)).thenReturn(UniqueId.of("Foo", "Bar"));
    assertEquals(instance.replaceVersion(doc), UniqueId.of("Foo", "Bar"));
  }

  public void testRemoveVersion() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    instance.removeVersion(UniqueId.of("Foo", "Bar"));
    Mockito.verify(mock, Mockito.only()).removeVersion(UniqueId.of("Foo", "Bar"));
  }

  public void testAddVersion() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final AbstractDocument doc = Mockito.mock(AbstractDocument.class);
    Mockito.when(mock.addVersion(ObjectId.of("Foo", "Bar"), doc)).thenReturn(UniqueId.of("Foo", "Bar", "1"));
    assertEquals(instance.addVersion(ObjectId.of("Foo", "Bar"), doc), UniqueId.of("Foo", "Bar", "1"));
  }

  public void testChangeManager() {
    final AbstractChangeProvidingMaster mock = Mockito.mock(AbstractChangeProvidingMaster.class);
    final AbstractQuerySplittingMaster instance = instance(mock);
    final ChangeManager cm = Mockito.mock(ChangeManager.class);
    Mockito.when(mock.changeManager()).thenReturn(cm);
    assertSame(instance.changeManager(), cm);
  }

}