brooklyn-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tbou...@apache.org
Subject [1/3] brooklyn-server git commit: rest tests for same types added
Date Mon, 08 Jan 2018 12:10:49 GMT
Repository: brooklyn-server
Updated Branches:
  refs/heads/master 483c4afbf -> 792f4dd79


rest tests for same types added


Project: http://git-wip-us.apache.org/repos/asf/brooklyn-server/repo
Commit: http://git-wip-us.apache.org/repos/asf/brooklyn-server/commit/2b5e55a0
Tree: http://git-wip-us.apache.org/repos/asf/brooklyn-server/tree/2b5e55a0
Diff: http://git-wip-us.apache.org/repos/asf/brooklyn-server/diff/2b5e55a0

Branch: refs/heads/master
Commit: 2b5e55a0465071a0592889bfe24520d0440effa5
Parents: 483c4af
Author: Alex Heneveld <alex.heneveld@cloudsoftcorp.com>
Authored: Fri Jan 5 12:24:36 2018 +0000
Committer: Alex Heneveld <alex.heneveld@cloudsoftcorp.com>
Committed: Fri Jan 5 12:24:36 2018 +0000

----------------------------------------------------------------------
 .../resources/BundleAndTypeResourcesTest.java   | 269 +++++++++++++++++++
 1 file changed, 269 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/2b5e55a0/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
----------------------------------------------------------------------
diff --git a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
index 87fa378..3672a7a 100644
--- a/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
+++ b/rest/rest-resources/src/test/java/org/apache/brooklyn/rest/resources/BundleAndTypeResourcesTest.java
@@ -71,6 +71,7 @@ import org.apache.brooklyn.util.collections.MutableMap;
 import org.apache.brooklyn.util.collections.MutableSet;
 import org.apache.brooklyn.util.core.ResourceUtils;
 import org.apache.brooklyn.util.core.osgi.BundleMaker;
+import org.apache.brooklyn.util.http.HttpAsserts;
 import org.apache.brooklyn.util.javalang.JavaClassNames;
 import org.apache.brooklyn.util.javalang.Reflections;
 import org.apache.brooklyn.util.os.Os;
@@ -85,6 +86,7 @@ import org.testng.annotations.Test;
 import org.testng.reporters.Files;
 
 import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
@@ -1095,4 +1097,271 @@ public class BundleAndTypeResourcesTest extends BrooklynRestResourceTest
{
         return currentExpectedToBeWorking;
     }
 
+    @Test
+    public void testAddSameTypeTwiceInSameBundle_SilentlyDeduped() throws Exception {
+        final String symbolicName = "test.duplicate.type."+JavaClassNames.niceClassAndMethod();
+        final String entityName = symbolicName+".type";
+
+        File jar = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+                "brooklyn.catalog:",
+                "  bundle: " + symbolicName,
+                "  version: " + TEST_VERSION,
+                "  items:",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    name: T",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    name: T",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity")));
+
+        Response result = client().path("/catalog/bundles")
+            .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+            .post(Streams.readFully(new FileInputStream(jar)));
+        HttpAsserts.assertHealthyStatusCode(result.getStatus());
+
+        TypeSummary entity = client().path("/catalog/types/" + entityName + "/" + TEST_VERSION)
+                .get(TypeSummary.class);
+        assertEquals(entity.getDisplayName(), "T");
+        
+        List<TypeSummary> entities = client().path("/catalog/types/" + entityName)
+                .get(new GenericType<List<TypeSummary>>() {});
+        Asserts.assertSize(entities, 1);
+        assertEquals(Iterables.getOnlyElement(entities), entity);
+        
+        BundleSummary bundle = client().path("/catalog/bundles/" + symbolicName + "/" + TEST_VERSION)
+            .get(BundleSummary.class);
+        Asserts.assertSize(bundle.getTypes(), 1);
+        assertEquals(Iterables.getOnlyElement(bundle.getTypes()), entity);
+
+    }
+    
+    @Test
+    // different metadata is allowed as that doesn't affect operation (but different definition
is not, see below)
+    // if in same bundle, it's deduped and last one wins; should warn and could disallow,
but if type is pulled in 
+    // multiple times from copied files, it feels convenient just to dedupe and forgive minor
metadata changes;
+    // if in different bundles, see other test below, but in that case both are added
+    public void testAddSameTypeTwiceInSameBundleDifferentDisplayName_LastOneWins() throws
Exception {
+        final String symbolicName = "test.duplicate.type."+JavaClassNames.niceClassAndMethod();
+        final String entityName = symbolicName+".type";
+
+        File jar = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+                "brooklyn.catalog:",
+                "  bundle: " + symbolicName,
+                "  version: " + TEST_VERSION,
+                "  items:",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    name: T",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    name: U",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity")));
+
+        Response result = client().path("/catalog/bundles")
+            .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+            .post(Streams.readFully(new FileInputStream(jar)));
+        HttpAsserts.assertHealthyStatusCode(result.getStatus());
+
+        TypeSummary entity = client().path("/catalog/types/" + entityName + "/" + TEST_VERSION)
+                .get(TypeSummary.class);
+        assertEquals(entity.getDisplayName(), "U");
+        
+        List<TypeSummary> entities = client().path("/catalog/types/" + entityName)
+                .get(new GenericType<List<TypeSummary>>() {});
+        Asserts.assertSize(entities, 1);
+        assertEquals(Iterables.getOnlyElement(entities), entity);
+        
+        BundleSummary bundle = client().path("/catalog/bundles/" + symbolicName + "/" + TEST_VERSION)
+            .get(BundleSummary.class);
+        Asserts.assertSize(bundle.getTypes(), 1);
+        assertEquals(Iterables.getOnlyElement(bundle.getTypes()), entity);
+    }
+    
+    @Test
+    // would be confusing if the _definition_ is different however, as one will be ignored
+    public void testAddSameTypeTwiceInSameBundleDifferentDefinition_Disallowed() throws Exception
{
+        final String symbolicName = "test.duplicate.type."+JavaClassNames.niceClassAndMethod();
+        final String entityName = symbolicName+".type";
+        final String entityNameOkay = symbolicName+".okayType";
+
+        File jar = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+                "brooklyn.catalog:",
+                "  bundle: " + symbolicName,
+                "  version: " + TEST_VERSION,
+                "  items:",
+                "  - id: " + entityNameOkay,
+                "    itemType: entity",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "      a.config: first_definition",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "      a.config: second_definition_makes_it_different_so_disallowed")));
+
+        Response result = client().path("/catalog/bundles")
+                .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+                .post(Streams.readFully(new FileInputStream(jar)));
+        HttpAsserts.assertNotHealthyStatusCode(result.getStatus());
+        String resultS = Streams.readFullyString((InputStream)result.getEntity());
+        Asserts.assertStringContainsIgnoreCase(resultS, "different plan", entityName);
+        Asserts.assertStringDoesNotContain(resultS, entityNameOkay);
+
+        // entity not added
+        Response get = client().path("/catalog/types/" + entityName + "/" + TEST_VERSION).get();
+        assertEquals(get.getStatus(), 404);
+        
+        List<TypeSummary> entities = client().path("/catalog/types/" + entityName)
+                .get(new GenericType<List<TypeSummary>>() {});
+        Asserts.assertSize(entities, 0);
+        
+        // nor is the okay entity
+        Response getOkay = client().path("/catalog/types/" + entityNameOkay + "/" + TEST_VERSION).get();
+        assertEquals(getOkay.getStatus(), 404);
+        
+        // and nor is the bundle
+        Response getBundle = client().path("/catalog/bundles/" + symbolicName + "/" + TEST_VERSION).get();
+        assertEquals(getBundle.getStatus(), 404);
+    }
+    
+    // TODO might in future want to allow this if the user adding the type cannot see the
other type due to entitlements;
+    // means however there might be another user who _can_ see the two different types 
+    private final static boolean DISALLOW_DIFFERENCES_IN_SAME_TYPE_ID_FROM_DIFFERENT_BUNDLES
= true;
+    
+    @Test
+    public void testAddSameTypeTwiceInDifferentBundleDifferentDefinition_Disallowed() throws
Exception {
+        Preconditions.checkArgument(DISALLOW_DIFFERENCES_IN_SAME_TYPE_ID_FROM_DIFFERENT_BUNDLES);
+        // if above changed, assert that both types are added
+        
+        final String symbolicName1 = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".1";
+        final String symbolicName2 = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".2";
+        final String entityName = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".type";
+
+        File jar1 = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+                "brooklyn.catalog:",
+                "  bundle: " + symbolicName1,
+                "  version: " + TEST_VERSION,
+                "  items:",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+                "      a.config: in_bundle1")));
+        Response result1 = client().path("/catalog/bundles")
+                .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+                .post(Streams.readFully(new FileInputStream(jar1)));
+        HttpAsserts.assertHealthyStatusCode(result1.getStatus());
+        
+        File jar2 = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+            "brooklyn.catalog:",
+            "  bundle: " + symbolicName2,
+            "  version: " + TEST_VERSION,
+            "  items:",
+            "  - id: " + entityName,
+            "    itemType: entity",
+            "    item:",
+            "      type: org.apache.brooklyn.core.test.entity.TestEntity",
+            "      a.config: in_bundle2")));
+        Response result2 = client().path("/catalog/bundles")
+            .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+            .post(Streams.readFully(new FileInputStream(jar2)));
+        String resultS = Streams.readFullyString((InputStream)result2.getEntity());
+        HttpAsserts.assertNotHealthyStatusCode(result2.getStatus());
+        Asserts.assertStringContainsIgnoreCase(resultS, "it is different to", entityName,
"different bundle", symbolicName1);
+    }
+    
+    @Test
+    // TODO fails as there is NOT a link to a specific type in a specific bundle currently
- API assumes type name+id unique
+    // but they may differ in the containing bundle (and maybe in future differ in more things)
+    // ==> bug about to be fixed!
+    public void testAddSameTypeTwiceInDifferentBundleSameDefinition_AllowedAndApiMakesTheDifferentOnesClear()
throws Exception {
+        final String symbolicName1 = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".1";
+        final String symbolicName2 = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".2";
+        final String entityName = "test.duplicate.type."+JavaClassNames.niceClassAndMethod()+".type";
+
+        File jar1 = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+                "brooklyn.catalog:",
+                "  bundle: " + symbolicName1,
+                "  version: " + TEST_VERSION,
+                "  items:",
+                "  - id: " + entityName,
+                "    itemType: entity",
+                "    name: T",
+                "    item:",
+                "      type: org.apache.brooklyn.core.test.entity.TestEntity")));
+        Response result1 = client().path("/catalog/bundles")
+                .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+                .post(Streams.readFully(new FileInputStream(jar1)));
+        HttpAsserts.assertHealthyStatusCode(result1.getStatus());
+        
+        File jar2 = createJar(ImmutableMap.<String, String>of("catalog.bom", Joiner.on("\n").join(
+            "brooklyn.catalog:",
+            "  bundle: " + symbolicName2,
+            "  version: " + TEST_VERSION,
+            "  items:",
+            "  - id: " + entityName,
+            "    itemType: entity",
+            "    name: U",
+            "    item:",
+            "      type: org.apache.brooklyn.core.test.entity.TestEntity")));
+        Response result2 = client().path("/catalog/bundles")
+            .header(HttpHeaders.CONTENT_TYPE, "application/x-jar")
+            .post(Streams.readFully(new FileInputStream(jar2)));
+        HttpAsserts.assertHealthyStatusCode(result2.getStatus());
+        
+        TypeSummary entity = client().path("/catalog/types/" + entityName + "/" + TEST_VERSION)
+            .get(TypeSummary.class);
+        // type should be present twice, but bundle 1 preferred because first alphanumerically;

+        assertEquals(entity.getContainingBundle(), symbolicName1+":"+TEST_VERSION);
+        // (however this might be weakened in future)
+//        Asserts.assertStringContains("["+symbolicName1+":"+TEST_VERSION+"] OR ["+symbolicName2+":"+TEST_VERSION+"]",

+//            "["+entity.getContainingBundle()+"]");
+        TypeSummary entity1 = entity;
+        
+        List<TypeSummary> entities = client().path("/catalog/types/" + entityName)
+                .get(new GenericType<List<TypeSummary>>() {});
+        Asserts.assertSize(entities, 2);
+        assertEquals(entities.get(0), entity1);
+        TypeSummary entity2 = entities.get(1);
+        assertEquals(entity2.getContainingBundle(), symbolicName2+":"+TEST_VERSION);
+        Assert.assertNotEquals(entity1, entity2);
+        
+        assertEquals(entity1.getDisplayName(), "T");
+        assertEquals(entity2.getDisplayName(), "U");
+        
+        BundleSummary bundle1 = client().path("/catalog/bundles/" + symbolicName1 + "/" +
TEST_VERSION)
+            .get(BundleSummary.class);
+        Asserts.assertSize(bundle1.getTypes(), 1);
+        assertEquals(Iterables.getOnlyElement(bundle1.getTypes()), entity1);        
+        
+        BundleSummary bundle2 = client().path("/catalog/bundles/" + symbolicName2 + "/" +
TEST_VERSION)
+            .get(BundleSummary.class);
+        Asserts.assertSize(bundle2.getTypes(), 1);
+        assertEquals(Iterables.getOnlyElement(bundle2.getTypes()), entity2);
+        
+        @SuppressWarnings("unchecked")
+        String self1 = ((Map<String,String>)entity1.getExtraFields().get("links")).get("self");
+        @SuppressWarnings("unchecked")
+        String self2 = ((Map<String,String>)entity2.getExtraFields().get("links")).get("self");
+        
+        Assert.assertNotEquals(self1, self2);
+        
+        TypeSummary entity1r = client().path(self1).get(TypeSummary.class);
+        TypeSummary entity2r = client().path(self1).get(TypeSummary.class);
+        Assert.assertEquals(entity1r, entity1);
+        Assert.assertEquals(entity2r, entity2);
+    }
+    
 }


Mime
View raw message