This is an automated email from the ASF dual-hosted git repository.
aledsage pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git
commit 9fe502a2d67835d60a23a0bbf5aa27f9c7a3caef
Author: Paul Campbell <pcampb...@kemitix.net>
AuthorDate: Wed Oct 24 17:06:24 2018 +0100
Add unit tests for CatalogUpgradeSCanner
---
.../internal/CatalogUpgradeScannerTest.java | 304 +++++++++++++++++++++
1 file changed, 304 insertions(+)
diff --git
a/core/src/test/java/org/apache/brooklyn/core/catalog/internal/CatalogUpgradeScannerTest.java
b/core/src/test/java/org/apache/brooklyn/core/catalog/internal/CatalogUpgradeScannerTest.java
new file mode 100644
index 0000000..a03a54e
--- /dev/null
+++
b/core/src/test/java/org/apache/brooklyn/core/catalog/internal/CatalogUpgradeScannerTest.java
@@ -0,0 +1,304 @@
+package org.apache.brooklyn.core.catalog.internal;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Multimap;
+import org.apache.brooklyn.api.typereg.ManagedBundle;
+import org.apache.brooklyn.api.typereg.OsgiBundleWithUrl;
+import org.apache.brooklyn.api.typereg.RegisteredType;
+import org.apache.brooklyn.core.mgmt.ha.OsgiManager;
+import org.apache.brooklyn.core.mgmt.internal.LocalManagementContext;
+import org.apache.brooklyn.core.mgmt.internal.ManagementContextInternal;
+import org.apache.brooklyn.core.typereg.BasicManagedBundle;
+import org.apache.brooklyn.core.typereg.BundleUpgradeParser.CatalogUpgrades;
+import org.apache.brooklyn.core.typereg.BundleUpgradeParser.VersionRangedName;
+import org.apache.brooklyn.util.guava.Maybe;
+import org.apache.brooklyn.util.osgi.VersionedName;
+import org.assertj.core.api.WithAssertions;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+import static
org.apache.brooklyn.core.catalog.internal.CatalogUpgradeScannerTest.Givens.*;
+import static
org.apache.brooklyn.core.catalog.internal.CatalogUpgradeScannerTest.Utils.*;
+import static org.apache.brooklyn.core.typereg.BundleTestUtil.newMockBundle;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+public class CatalogUpgradeScannerTest implements WithAssertions {
+
+ // collaborators
+ private final ManagementContextInternal managementContext = new
LocalManagementContext();
+ @Mock
+ private BiFunction<Bundle, RegisteredTypesSupplier, CatalogUpgrades>
bundleUpgradeParser;
+ @Mock
+ private Function<OsgiBundleWithUrl, Predicate<? super RegisteredType>>
managedBundlePredicateSupplier;
+ @Mock
+ private Function<String, Predicate<? super RegisteredType>>
unmanagedBundlePredicateSupplier;
+
+ // subject under test
+ private CatalogUpgradeScanner scanner;
+
+ // parameters
+ private final OsgiManager osgiManager = mock(OsgiManager.class);
+ private final CatalogInitialization.RebindLogger rebindLogger =
mock(CatalogInitialization.RebindLogger.class);
+ private final BundleContext bundleContext = mock(BundleContext.class);
+
+ @BeforeClass
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ scanner = new CatalogUpgradeScanner(managementContext,
bundleUpgradeParser, managedBundlePredicateSupplier,
+ unmanagedBundlePredicateSupplier);
+ }
+
+ private CatalogUpgrades invoke() {
+ return scanner.scan(osgiManager, bundleContext, rebindLogger);
+ }
+
+ @Test
+ public void whenNoUnmanagedOrManagedBundlesThenNoUpgrades() {
+ //given
+ givenNoManagedBundles(osgiManager);
+ givenNoUnmanagedBundles(bundleContext);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatThereAreNoUpgrades(result);
+ }
+
+ @Test
+ public void whenUnmanagedAndManagedBundlesWithNoUpgradesThenNoUpgrades() {
+ //given
+ givenManagedBundlesWithNoUpgrades(osgiManager, bundleUpgradeParser);
+ givenUnmanagedBundlesWithNoUpgrades(bundleContext,
bundleUpgradeParser);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatThereAreNoUpgrades(result);
+ }
+
+ @Test
+ public void whenOnlyManagedBundleHasUpgradesThenUpgradesForManagedBundle()
{
+ //given
+ final String upgradeFrom = bundleName("managed", "1.0.0");
+ final String upgradeTo = bundleName("managed", "2.0.0");
+ final CatalogUpgrades catalogUpgrades = CatalogUpgrades.builder()
+ .upgradeBundles(upgradeMapping(upgradeFrom, upgradeTo))
+ .build();
+ givenManagedBundlesWithUpgrades(catalogUpgrades, osgiManager,
bundleUpgradeParser);
+ givenUnmanagedBundlesWithNoUpgrades(bundleContext,
bundleUpgradeParser);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatBundleHasUpgrades(result, upgradeFrom, upgradeTo);
+ }
+
+ @Test
+ public void
whenOnlyManagedBundleHasUpgradesThenNoUpgradesForUnmanagedBundles() {
+ //given
+ final String upgradeFrom = bundleName("managed", "1.0.0");
+ final String upgradeTo = bundleName("managed", "2.0.0");
+ final CatalogUpgrades catalogUpgrades = CatalogUpgrades.builder()
+ .upgradeBundles(upgradeMapping(upgradeFrom, upgradeTo))
+ .build();
+ givenManagedBundlesWithUpgrades(catalogUpgrades, osgiManager,
bundleUpgradeParser);
+ final String unmanagedBundle = bundleName("unmanaged", "1.1.0");
+ givenUnmanagedBundleWithNoUpgrades(unmanagedBundle, bundleContext,
bundleUpgradeParser);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatBundleHasNoUpgrades(result, unmanagedBundle);
+ }
+
+ @Test
+ public void
whenOnlyUnmanagedBundleHasUpgradesThenUpgradesForUnmanagedBundle() {
+ //given
+ final String upgradeFrom = bundleName("unmanaged", "1.0.0");
+ final String upgradeTo = bundleName("unmanaged", "2.0.0");
+ final CatalogUpgrades catalogUpgrades = CatalogUpgrades.builder()
+ .upgradeBundles(upgradeMapping(upgradeFrom, upgradeTo))
+ .build();
+ givenManagedBundlesWithNoUpgrades(osgiManager, bundleUpgradeParser);
+ givenUnmanagedBundleWithUpgrades(catalogUpgrades, bundleContext,
bundleUpgradeParser);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatBundleHasUpgrades(result, upgradeFrom, upgradeTo);
+ }
+
+ @Test
+ public void
whenOnlyUnmanagedBundleHasUpgradesThenNoUpgradesForManagedBundles() {
+ //given
+ final String upgradeFrom = bundleName("unmanaged", "1.0.0");
+ final String upgradeTo = bundleName("unmanaged", "2.0.0");
+ final CatalogUpgrades catalogUpgrades = CatalogUpgrades.builder()
+ .upgradeBundles(upgradeMapping(upgradeFrom, upgradeTo))
+ .build();
+ final String managedBundle = bundleName("managed", "1.1.0");
+ givenManagedBundleWithNoUpgrades(managedBundle, osgiManager,
bundleUpgradeParser);
+ givenUnmanagedBundleWithUpgrades(catalogUpgrades, bundleContext,
bundleUpgradeParser);
+ //when
+ final CatalogUpgrades result = invoke();
+ //then
+ assertThatBundleHasNoUpgrades(result, managedBundle);
+ }
+
+ static class Givens {
+
+ static void givenNoManagedBundles(final OsgiManager osgiManager) {
+ final Map<String, ManagedBundle> noBundles =
Collections.emptyMap();
+ given(osgiManager.getManagedBundles()).willReturn(noBundles);
+ }
+
+ static void givenNoUnmanagedBundles(BundleContext bundleContext) {
+ final Bundle[] noBundles = new Bundle[0];
+ given(bundleContext.getBundles()).willReturn(noBundles);
+ }
+
+ static void givenManagedBundlesWithNoUpgrades(
+ final OsgiManager osgiManager,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Map<String, ManagedBundle> managedBundlesWithNoUpgrades =
+ ImmutableMap.of(
+ "managed1", findableManagedBundle(osgiManager,
CatalogUpgrades.EMPTY, bundleUpgradeParser),
+ "managed2", findableManagedBundle(osgiManager,
CatalogUpgrades.EMPTY, bundleUpgradeParser)
+ );
+
doReturn(managedBundlesWithNoUpgrades).when(osgiManager).getManagedBundles();
+ }
+
+ static void givenManagedBundlesWithUpgrades(
+ final CatalogUpgrades upgrades,
+ final OsgiManager osgiManager,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Map<String, ManagedBundle> managedBundlesWithNoUpgrades =
+ ImmutableMap.of("managed",
findableManagedBundle(osgiManager, upgrades, bundleUpgradeParser));
+
doReturn(managedBundlesWithNoUpgrades).when(osgiManager).getManagedBundles();
+ }
+
+ static void givenManagedBundleWithNoUpgrades(
+ final String bundleName,
+ final OsgiManager osgiManager,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final ManagedBundle managedBundle =
+ findableManagedBundle(osgiManager, CatalogUpgrades.EMPTY,
bundleUpgradeParser);
+ final Map<String, ManagedBundle> managedBundlesWithNoUpgrades =
+ ImmutableMap.of(bundleName, managedBundle);
+
doReturn(managedBundlesWithNoUpgrades).when(osgiManager).getManagedBundles();
+ }
+
+ static void givenUnmanagedBundlesWithNoUpgrades(
+ final BundleContext bundleContext,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Bundle[] unmanagedBundlesWithNoUpgrades = new Bundle[]{
+ unmanagedBundle(bundleName("unmanaged1", "1.1.0"),
CatalogUpgrades.EMPTY, bundleUpgradeParser),
+ unmanagedBundle(bundleName("unmanaged2", "1.1.0"),
CatalogUpgrades.EMPTY, bundleUpgradeParser)
+ };
+
doReturn(unmanagedBundlesWithNoUpgrades).when(bundleContext).getBundles();
+ }
+
+ static void givenUnmanagedBundleWithNoUpgrades(
+ final String bundleName,
+ final BundleContext bundleContext,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Bundle[] unmanagedBundlesWithNoUpgrades = new Bundle[]{
+ unmanagedBundle(bundleName, CatalogUpgrades.EMPTY,
bundleUpgradeParser)
+ };
+
doReturn(unmanagedBundlesWithNoUpgrades).when(bundleContext).getBundles();
+ }
+
+ static void givenUnmanagedBundleWithUpgrades(
+ final CatalogUpgrades upgrades,
+ final BundleContext bundleContext,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Bundle[] unmanagedBundlesWithNoUpgrades = new Bundle[]{
+ unmanagedBundle(bundleName("unmanaged", "1.1.0"),
upgrades, bundleUpgradeParser)
+ };
+
doReturn(unmanagedBundlesWithNoUpgrades).when(bundleContext).getBundles();
+ }
+
+ }
+
+ void assertThatThereAreNoUpgrades(final CatalogUpgrades result) {
+ assertSoftly(s -> {
+
s.assertThat(result.getUpgradesProvidedByBundles().size()).isZero();
+ s.assertThat(result.getUpgradesProvidedByTypes().size()).isZero();
+ });
+ }
+
+ void assertThatBundleHasUpgrades(
+ final CatalogUpgrades result,
+ final String upgradeFrom,
+ final String upgradeTo
+ ) {
+
assertThat(result.getUpgradesForBundle(VersionedName.fromString(upgradeFrom)))
+ .contains(VersionedName.fromString(upgradeTo));
+ }
+
+ void assertThatBundleHasNoUpgrades(
+ final CatalogUpgrades result,
+ final String unmanagedBundle
+ ) {
+
assertThat(result.getUpgradesForBundle(VersionedName.fromString(unmanagedBundle))).isEmpty();
+ }
+
+ static class Utils {
+
+ static Bundle unmanagedBundle(
+ String bundleName, final CatalogUpgrades catalogUpgrades,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final Bundle bundle =
newMockBundle(VersionedName.fromString(bundleName), ImmutableMap.of());
+ given(bundleUpgradeParser.apply(eq(bundle),
any())).willReturn(catalogUpgrades);
+ return bundle;
+ }
+
+ static ManagedBundle findableManagedBundle(
+ final OsgiManager osgiManager,
+ final CatalogUpgrades catalogUpgrades,
+ final BiFunction<Bundle, RegisteredTypesSupplier,
CatalogUpgrades> bundleUpgradeParser
+ ) {
+ final ManagedBundle managedBundle = new BasicManagedBundle();
+ final Bundle bundle = mock(Bundle.class);
+
given(osgiManager.findBundle(managedBundle)).willReturn(Maybe.of(bundle));
+ given(bundleUpgradeParser.apply(eq(bundle),
any())).willReturn(catalogUpgrades);
+ return managedBundle;
+ }
+
+ static String bundleName(
+ final String name,
+ final String version
+ ) {
+ return name + ":" + version;
+ }
+
+ static Multimap<VersionedName, VersionRangedName> upgradeMapping(
+ final String upgradeFrom,
+ final String upgradeTo
+ ) {
+ return ImmutableMultimap.of(
+ VersionedName.fromString(upgradeTo),
+ VersionRangedName.fromString(upgradeFrom, true));
+ }
+
+ }
+
+}
\ No newline at end of file
