How to use

AlaSPITestCommons

in

org.guvnor.ala

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

@Test
public void testGetProvidersByType() {
  ProviderType providerType1 = mockProviderTypeSPI("ProviderType1");
  ProviderType providerType2 = mockProviderTypeSPI("ProviderType2");
  List<Provider> providers = mockProviderListSPI(providerType,
                          "1",
                          ELEMENTS_COUNT);
  List<Provider> providersForType1 = mockProviderListSPI(providerType1,
                              "2",
                              ELEMENTS_COUNT);
  List<Provider> providersForType2 = mockProviderListSPI(providerType2,
                              ELEMENTS_COUNT);
  List<Provider> allProviders = new ArrayList<>();
  allProviders.addAll(providers);
  allProviders.addAll(providersForType1);
  allProviders.addAll(providersForType2);
  allProviders.forEach(provider -> runtimeRegistry.registerProvider(provider));
  List<Provider> result = runtimeRegistry.getProvidersByType(providerType);
  assertEquals(providers.size(),
         result.size());
  for (Provider provider : providers) {
    assertTrue(result.contains(provider));
  }
}

@Before
public void setUp() {
  providerType = mockProviderTypeSPI("");
  provider = mockProviderSPI(providerType,
                "");
  providerId = mock(ProviderId.class);
  when(providerId.getProviderType()).thenReturn(providerType);
  when(providerId.getId()).thenReturn(PROVIDER_ID);
  runtime = mockRuntime(providerId,
             "");
  runtimeRegistry = new InMemoryRuntimeRegistry();
}

public static List<Provider> mockProviderListSPI(final ProviderType providerType,
                         int count) {
  return mockProviderListSPI(providerType,
                "",
                count);
}

public static List<ProviderType> mockProviderTypeListSPI(final int count) {
  List<ProviderType> providerTypes = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    //mock an arbitrary set of provider types.
    providerTypes.add(mockProviderTypeSPI(Integer.toString(i)));
  }
  return providerTypes;
}

@Before
public void setUp() {
  providerTypesSpi = mockProviderTypeListSPI(PROVIDER_TYPES_COUNT);
  when(scopeFactory.createScope(GuvnorPreferenceScopes.GLOBAL)).thenReturn(preferenceScope);
  provisioningPreferences = spy(new ProvisioningPreferences() {
    {
      setProviderTypeEnablements(new HashMap<>());
    }
    @Override
    public void load() {
    }
    @Override
    public void save(PreferenceScope customScope) {
    }
  });
  when(runtimeProvisioningService.getProviderTypes(anyInt(),
                           anyInt(),
                           anyString(),
                           anyBoolean())).thenReturn(providerTypesSpi);
  service = new ProviderTypeServiceImpl(runtimeProvisioningService,
                     provisioningPreferences,
                     scopeFactory);
}

public static List<Provider> mockProviderListSPI(final ProviderType providerType,
                         final String suffix,
                         int count) {
  List<Provider> providers = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    providers.add(mockProviderSPI(providerType,
                   Integer.toString(i) + suffix));
  }
  return providers;
}

public static List<Provider> mockProviderListSPI(final ProviderType providerType,
                         int count) {
  return mockProviderListSPI(providerType,
                "",
                count);
}

public static List<ProviderType> mockProviderTypeListSPI(final int count) {
  List<ProviderType> providerTypes = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    //mock an arbitrary set of provider types.
    providerTypes.add(mockProviderTypeSPI(Integer.toString(i)));
  }
  return providerTypes;
}

@Before
public void setUp() {
  providerTypesSpi = mockProviderTypeListSPI(PROVIDER_TYPES_COUNT);
  when(globalPreferenceScope.resolve()).thenReturn(preferenceScope);
  provisioningPreferences = spy(new ProvisioningPreferences() {
    {
      setProviderTypeEnablements(new HashMap<>());
    }
    @Override
    public void load() {
    }
    @Override
    public void save(PreferenceScope customScope) {
    }
  });
  when(runtimeProvisioningService.getProviderTypes(anyInt(),
                           anyInt(),
                           anyString(),
                           anyBoolean())).thenReturn(providerTypesSpi);
  service = new ProviderTypeServiceImpl(runtimeProvisioningService,
                     provisioningPreferences,
                     globalPreferenceScope);
}

public static List<Provider> mockProviderListSPI(final ProviderType providerType,
                         final String suffix,
                         int count) {
  List<Provider> providers = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    providers.add(mockProviderSPI(providerType,
                   Integer.toString(i) + suffix));
  }
  return providers;
}

@Test
public void testGetProvidersByType() {
  ProviderType providerType1 = mockProviderTypeSPI("ProviderType1");
  ProviderType providerType2 = mockProviderTypeSPI("ProviderType2");
  List<Provider> providers = mockProviderListSPI(providerType,
                          "1",
                          ELEMENTS_COUNT);
  List<Provider> providersForType1 = mockProviderListSPI(providerType1,
                              "2",
                              ELEMENTS_COUNT);
  List<Provider> providersForType2 = mockProviderListSPI(providerType2,
                              ELEMENTS_COUNT);
  List<Provider> allProviders = new ArrayList<>();
  allProviders.addAll(providers);
  allProviders.addAll(providersForType1);
  allProviders.addAll(providersForType2);
  allProviders.forEach(provider -> runtimeRegistry.registerProvider(provider));
  List<Provider> result = runtimeRegistry.getProvidersByType(providerType);
  assertEquals(providers.size(),
         result.size());
  for (Provider provider : providers) {
    assertTrue(result.contains(provider));
  }
}

  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 testGetProviders() {
  List<Provider> result = runtimeRegistry.getProviders(0,
                             1000,
                             RuntimeRegistry.PROVIDER_ID_SORT,
                             true);
  assertTrue(result.isEmpty());
  List<Provider> providers = mockProviderListSPI(providerType,
                          ELEMENTS_COUNT);
  providers.forEach(provider -> runtimeRegistry.registerProvider(provider));
  result = runtimeRegistry.getProviders(0,
                     1000,
                     RuntimeRegistry.PROVIDER_ID_SORT,
                     true);
  for (Provider provider : providers) {
    assertTrue(result.contains(provider));
  }
}

@Before
public void setUp() {
  when(pipeline.getName()).thenReturn(PIPELINE_ID);
  providerType = mockProviderTypeSPI("");
  pipelineRegistry = new InMemoryPipelineRegistry();
}

@Before
public void setUp() {
  providerType = mockProviderTypeSPI("");
  provider = mockProviderSPI(providerType,
                "");
  providerId = mock(ProviderId.class);
  when(providerId.getProviderType()).thenReturn(providerType);
  when(providerId.getId()).thenReturn(PROVIDER_ID);
  runtime = mockRuntime(providerId,
             "");
  runtimeRegistry = new InMemoryRuntimeRegistry();
}

@Test
public void testGetProviderTypes() {
  List<ProviderType> result = runtimeRegistry.getProviderTypes(0,
                                 1000,
                                 RuntimeRegistry.PROVIDER_TYPE_NAME_SORT,
                                 true);
  assertTrue(result.isEmpty());
  List<ProviderType> providerTypes = mockProviderTypeListSPI(ELEMENTS_COUNT);
  providerTypes.forEach(providerType -> runtimeRegistry.registerProviderType(providerType));
  result = runtimeRegistry.getProviderTypes(0,
                       1000,
                       RuntimeRegistry.PROVIDER_TYPE_NAME_SORT,
                       true);
  for (ProviderType providerType : providerTypes) {
    assertTrue(result.contains(providerType));
  }
}

@Before
public void setUp() {
  providerTypeSpi = mockProviderTypeSPI("0");
  providersSpi = mockProviderListSPI(providerTypeSpi,
                    PROVIDER_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));
    }
  }
}

@Test
public void testGetProviders() {
  List<Provider> result = runtimeRegistry.getProviders(0,
                             1000,
                             RuntimeRegistry.PROVIDER_ID_SORT,
                             true);
  assertTrue(result.isEmpty());
  List<Provider> providers = mockProviderListSPI(providerType,
                          ELEMENTS_COUNT);
  providers.forEach(provider -> runtimeRegistry.registerProvider(provider));
  result = runtimeRegistry.getProviders(0,
                     1000,
                     RuntimeRegistry.PROVIDER_ID_SORT,
                     true);
  for (Provider provider : providers) {
    assertTrue(result.contains(provider));
  }
}