How to use

mockList

method

in

org.guvnor.ala.AlaSPITestCommons

@Before
public void setUp() {
  configs = mockList(Config.class,
            CONFIG_COUNT);
}

  private void prepareReadEntries() throws Exception {
    entryPaths = mockList(Path.class,
               ENTRY_COUNT);
    Iterator<Path> pathIterator = entryPaths.iterator();

    expectedObjects = mockList(Object.class,
                  ENTRY_COUNT);

    entries = mockList(VFSRegistryEntry.class,
              ENTRY_COUNT);

    DirectoryStream<Path> directoryStream = mock(DirectoryStream.class);
    when(directoryStream.iterator()).thenReturn(pathIterator);

    when(ioService.newDirectoryStream(rootPath,
                     filter)).thenReturn(directoryStream);

    for (int i = 0; i < ENTRY_COUNT; i++) {
      VFSRegistryEntry entry = entries.get(i);
      when(ioService.readAllString(entryPaths.get(i))).thenReturn(MARSHALLED_ENTRY + i);
      when(entryMarshaller.unmarshal(MARSHALLED_ENTRY + i)).thenReturn(entry);
      when(entry.getContentType()).thenReturn(Object.class.getName());
      when(entry.getContent()).thenReturn(MARSHALLED_VALUE + i);
      when(marshallerRegistry.get(any(Class.class))).thenReturn(marshaller);
      when(marshaller.unmarshal(MARSHALLED_VALUE + i)).thenReturn(expectedObjects.get(i));
    }
  }
}

  private void prepareReadEntries() throws Exception {
    entryPaths = mockList(Path.class,
               ENTRY_COUNT);
    Iterator<Path> pathIterator = entryPaths.iterator();

    expectedObjects = mockList(Object.class,
                  ENTRY_COUNT);

    entries = mockList(VFSRegistryEntry.class,
              ENTRY_COUNT);

    DirectoryStream<Path> directoryStream = mock(DirectoryStream.class);
    when(directoryStream.iterator()).thenReturn(pathIterator);

    when(ioService.newDirectoryStream(rootPath,
                     filter)).thenReturn(directoryStream);

    for (int i = 0; i < ENTRY_COUNT; i++) {
      VFSRegistryEntry entry = entries.get(i);
      when(ioService.readAllString(entryPaths.get(i))).thenReturn(MARSHALLED_ENTRY + i);
      when(entryMarshaller.unmarshal(MARSHALLED_ENTRY + i)).thenReturn(entry);
      when(entry.getContentType()).thenReturn(Object.class.getName());
      when(entry.getContent()).thenReturn(MARSHALLED_VALUE + i);
      when(marshallerRegistry.get(any(Class.class))).thenReturn(marshaller);
      when(marshaller.unmarshal(MARSHALLED_VALUE + i)).thenReturn(expectedObjects.get(i));
    }
  }
}

  @Test
  public void testExecuteQuery() {
    RuntimeQuery query = mock(RuntimeQuery.class);
    List<RuntimeQueryResultItem> values = mockList(RuntimeQueryResultItem.class,
                            ELEMENTS_COUNT);
    RuntimeQueryResultItemList list = new RuntimeQueryResultItemList(values);
    when(runtimeProvisioningService.executeQuery(query)).thenReturn(list);

    List<RuntimeQueryResultItem> result = runtimeProvisioningServiceBackend.executeQuery(query);
    verify(runtimeProvisioningService,
        times(1)).executeQuery(query);
    assertEquals(values,
           result);
  }
}

  @Test
  public void testOnDeleteContainer() {
    //mock an arbitrary set of configs.
    List<ContainerConfig> currentElements = mockList(ContainerConfig.class,
                             CONTAINER_CONFIG_COUNT);
    when(dataProvider.getList()).thenReturn(currentElements);

    //pick an arbitrary element for deletion.
    int originalSize = currentElements.size();
    int index = 4;
    ContainerConfig arbitraryElement = currentElements.get(index);
    presenter.onDeleteContainer(arbitraryElement);

    assertEquals(originalSize - 1,
           currentElements.size());
    assertFalse(currentElements.contains(arbitraryElement));
    verify(configParamsChangeEvent,
        times(1)).fire(new ContainerConfigParamsChangeEvent(currentElements));
    verify(contentChangeHandler,
        times(1)).onContentChange();
  }
}

  @Test
  public void testOnDeleteContainer() {
    //mock an arbitrary set of configs.
    List<ContainerConfig> currentElements = mockList(ContainerConfig.class,
                             CONTAINER_CONFIG_COUNT);
    when(dataProvider.getList()).thenReturn(currentElements);

    //pick an arbitrary element for deletion.
    int originalSize = currentElements.size();
    int index = 4;
    ContainerConfig arbitraryElement = currentElements.get(index);
    presenter.onDeleteContainer(arbitraryElement);

    assertEquals(originalSize - 1,
           currentElements.size());
    assertFalse(currentElements.contains(arbitraryElement));
    verify(configParamsChangeEvent,
        times(1)).fire(new ContainerConfigParamsChangeEvent(currentElements));
    verify(contentChangeHandler,
        times(1)).onContentChange();
  }
}

@Test
public void testGetRuntimes() {
  List<Runtime> values = mockList(Runtime.class,
                  ELEMENTS_COUNT);
  RuntimeList list = new RuntimeList(values);
  when(runtimeProvisioningService.getRuntimes(PAGE,
                        PAGE_SIZE,
                        SORT,
                        SORT_ORDER)).thenReturn(list);
  List<Runtime> result = runtimeProvisioningServiceBackend.getRuntimes(PAGE,
                                     PAGE_SIZE,
                                     SORT,
                                     SORT_ORDER);
  verify(runtimeProvisioningService,
      times(1)).getRuntimes(PAGE,
                 PAGE_SIZE,
                 SORT,
                 SORT_ORDER);
  assertEquals(values,
         result);
}

@Test
public void testGetProviders() {
  List<Provider> values = mockList(Provider.class,
                   ELEMENTS_COUNT);
  ProviderList list = new ProviderList(values);
  when(runtimeProvisioningService.getProviders(PAGE,
                         PAGE_SIZE,
                         SORT,
                         SORT_ORDER)).thenReturn(list);
  List<Provider> result = runtimeProvisioningServiceBackend.getProviders(PAGE,
                                      PAGE_SIZE,
                                      SORT,
                                      SORT_ORDER);
  verify(runtimeProvisioningService,
      times(1)).getProviders(PAGE,
                 PAGE_SIZE,
                 SORT,
                 SORT_ORDER);
  assertEquals(values,
         result);
}

@Test
public void testGetPipelineConfigs() {
  List<PipelineConfig> values = mockList(PipelineConfig.class,
                      ELEMENTS_COUNT);
  PipelineConfigsList list = new PipelineConfigsList(values);
  when(pipelineService.getPipelineConfigs(PAGE,
                      PAGE_SIZE,
                      SORT,
                      SORT_ORDER)).thenReturn(list);
  List<PipelineConfig> result = pipelineServiceBackend.getPipelineConfigs(PAGE,
                                      PAGE_SIZE,
                                      SORT,
                                      SORT_ORDER);
  verify(pipelineService,
      times(1)).getPipelineConfigs(PAGE,
                    PAGE_SIZE,
                    SORT,
                    SORT_ORDER);
  assertEquals(result,
         values);
}

@Test
public void testGetProviderTypes() {
  List<ProviderType> values = mockList(ProviderType.class,
                     ELEMENTS_COUNT);
  ProviderTypeList list = new ProviderTypeList(values);
  when(runtimeProvisioningService.getProviderTypes(PAGE,
                           PAGE_SIZE,
                           SORT,
                           SORT_ORDER)).thenReturn(list);
  List<ProviderType> result = runtimeProvisioningServiceBackend.getProviderTypes(PAGE,
                                          PAGE_SIZE,
                                          SORT,
                                          SORT_ORDER);
  verify(runtimeProvisioningService,
      times(1)).getProviderTypes(PAGE,
                   PAGE_SIZE,
                   SORT,
                   SORT_ORDER);
  assertEquals(values,
         result);
}

@Test
public void testGetPipelineConfigsForProviderType() {
  List<PipelineConfig> values = mockList(PipelineConfig.class,
                      ELEMENTS_COUNT);
  PipelineConfigsList list = new PipelineConfigsList(values);
  when(pipelineService.getPipelineConfigs(PROVIDER_TYPE_NAME,
                      PROVIDER_TYPE_VERSION,
                      PAGE,
                      PAGE_SIZE,
                      SORT,
                      SORT_ORDER)).thenReturn(list);
  List<PipelineConfig> result = pipelineServiceBackend.getPipelineConfigs(providerType,
                                      PAGE,
                                      PAGE_SIZE,
                                      SORT,
                                      SORT_ORDER);
  verify(pipelineService,
      times(1)).getPipelineConfigs(PROVIDER_TYPE_NAME,
                    PROVIDER_TYPE_VERSION,
                    PAGE,
                    PAGE_SIZE,
                    SORT,
                    SORT_ORDER);
  assertEquals(result,
         values);
}