gerrit.onap Code Review - policy/common.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * policy-endpoints
   4  * ================================================================================
   5  * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.common.endpoints.event.comm.bus;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_ALLOW_SELF_SIGNED_CERTIFICATES_SUFFIX;
  28 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_EP_CONN_TIMEOUT_SUFFIX;
  29 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_EP_READ_TIMEOUT_MS_SUFFIX;
  30 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_ROUNDTRIP_TIMEOUT_MS_SUFFIX;
  31 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_ROUTE_OFFER_SUFFIX;
  32 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_SESSION_STICKINESS_REQUIRED_SUFFIX;
  33 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_SUB_CONTEXT_PATH_SUFFIX;
  34 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_DME2_VERSION_SUFFIX;
  35 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_DMAAP_SINK_TOPICS;
  36 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX;
  37 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX;
  38 import static org.onap.policy.common.endpoints.properties.PolicyEndPointProperties.PROPERTY_TOPIC_SERVERS_SUFFIX;
  39
  40 import java.util.Arrays;
  41 import java.util.Collections;
  42 import java.util.LinkedList;
  43 import java.util.List;
  44 import java.util.Map;
  45 import java.util.Properties;
  46 import java.util.function.Function;
  47 import org.junit.After;
  48 import org.junit.Before;
  49 import org.junit.Test;
  50 import org.onap.policy.common.endpoints.event.comm.bus.internal.BusTopicParams;
  51
  52 public class DmaapTopicSinkFactoryTest extends BusTopicTestBase {
  53
  54     private static final String SERVER = "my-server";
  55     private static final String TOPIC2 = "my-topic-2";
  56
  57     private static final String MY_CONN_TIMEOUT = "200";
  58     private static final String MY_READ_TIMEOUT = "201";
  59     private static final String MY_ROUNDTRIP_TIMEOUT = "202";
  60     private static final String MY_STICKINESS = "true";
  61     private static final String MY_SUBCONTEXT = "my-subcontext";
  62     private static final String MY_DME_VERSION = "my-version";
  63
  64     private SinkFactory factory;
  65
  66     /**
  67      * Creates the object to be tested.
  68      */
  69     @Before
  70     public void setUp() {
  71         super.setUp();
  72
  73         factory = new SinkFactory();
  74     }
  75
  76     @After
  77     public void tearDown() {
  78         factory.destroy();
  79     }
  80
  81     @Test
  82     public void testBuildBusTopicParams() {
  83         // two unmanaged topics
  84         DmaapTopicSink sink = factory.build(makeBuilder().managed(false).build());
  85         DmaapTopicSink sink2 = factory.build(makeBuilder().managed(false).topic(TOPIC2).build());
  86         assertNotNull(sink);
  87         assertNotNull(sink2);
  88         assertTrue(sink != sink2);
  89
  90         // duplicate topics, but since they aren't managed, they should be different
  91         DmaapTopicSink sink3 = factory.build(makeBuilder().managed(false).build());
  92         DmaapTopicSink sink4 = factory.build(makeBuilder().managed(false).build());
  93         assertNotNull(sink3);
  94         assertNotNull(sink4);
  95         assertTrue(sink != sink3);
  96         assertTrue(sink != sink4);
  97         assertTrue(sink3 != sink4);
  98
  99         // two managed topics
 100         DmaapTopicSink sink5 = factory.build(makeBuilder().build());
 101         DmaapTopicSink sink6 = factory.build(makeBuilder().topic(TOPIC2).build());
 102         assertNotNull(sink5);
 103         assertNotNull(sink6);
 104
 105         // re-build same managed topics - should get exact same objects
 106         assertTrue(sink5 == factory.build(BusTopicParams.builder().topic(MY_TOPIC).build()));
 107         assertTrue(sink6 == factory.build(makeBuilder().topic(TOPIC2).build()));
 108     }
 109
 110     @Test(expected = IllegalArgumentException.class)
 111     public void testBuildBusTopicParams_NullTopic() {
 112         factory.build(makeBuilder().topic(null).build());
 113     }
 114
 115     @Test(expected = IllegalArgumentException.class)
 116     public void testBuildBusTopicParams_EmptyTopic() {
 117         factory.build(makeBuilder().topic("").build());
 118     }
 119
 120     @Test
 121     public void testBuildListOfStringString() {
 122         DmaapTopicSink sink1 = factory.build(servers, MY_TOPIC);
 123         assertNotNull(sink1);
 124
 125         // check parameters that were used
 126         BusTopicParams params = factory.params.get(0);
 127         assertEquals(servers, params.getServers());
 128         assertEquals(MY_TOPIC, params.getTopic());
 129         assertEquals(true, params.isManaged());
 130         assertEquals(false, params.isUseHttps());
 131         assertEquals(false, params.isAllowSelfSignedCerts());
 132
 133         DmaapTopicSink sink2 = factory.build(servers, TOPIC2);
 134         assertNotNull(sink2);
 135         assertTrue(sink1 != sink2);
 136
 137         // duplicate - should be the same as these topics are managed
 138         DmaapTopicSink sink3 = factory.build(Collections.emptyList(), TOPIC2);
 139         assertTrue(sink2 == sink3);
 140     }
 141
 142     @Test
 143     public void testBuildProperties() {
 144         assertEquals(1, factory.build(makePropBuilder().makeTopic(MY_TOPIC).build()).size());
 145
 146         BusTopicParams params = factory.params.get(0);
 147         assertEquals(true, params.isManaged());
 148         assertEquals(true, params.isUseHttps());
 149         assertEquals(true, params.isAllowSelfSignedCerts());
 150         assertEquals(MY_API_KEY, params.getApiKey());
 151         assertEquals(MY_API_SECRET, params.getApiSecret());
 152         assertEquals(MY_ENV, params.getEnvironment());
 153         assertEquals(MY_LAT, params.getLatitude());
 154         assertEquals(MY_LONG, params.getLongitude());
 155         assertEquals(MY_PARTITION, params.getPartitionId());
 156         assertEquals(MY_PARTNER, params.getPartner());
 157         assertEquals(Arrays.asList(SERVER), params.getServers());
 158         assertEquals(MY_TOPIC, params.getTopic());
 159
 160         Map<String, String> add = params.getAdditionalProps();
 161         assertEquals(MY_CONN_TIMEOUT, add.get(DmaapTopicSinkFactory.DME2_EP_CONN_TIMEOUT_PROPERTY));
 162         assertEquals(MY_READ_TIMEOUT, add.get(DmaapTopicSinkFactory.DME2_READ_TIMEOUT_PROPERTY));
 163         assertEquals(MY_ROUNDTRIP_TIMEOUT, add.get(DmaapTopicSinkFactory.DME2_ROUNDTRIP_TIMEOUT_PROPERTY));
 164         assertEquals(MY_ROUTE, add.get(DmaapTopicSinkFactory.DME2_ROUTE_OFFER_PROPERTY));
 165         assertEquals(MY_STICKINESS, add.get(DmaapTopicSinkFactory.DME2_SESSION_STICKINESS_REQUIRED_PROPERTY));
 166         assertEquals(MY_SUBCONTEXT, add.get(DmaapTopicSinkFactory.DME2_SUBCONTEXT_PATH_PROPERTY));
 167         assertEquals(MY_DME_VERSION, add.get(DmaapTopicSinkFactory.DME2_VERSION_PROPERTY));
 168     }
 169
 170     @Test
 171     public void testBuildProperties_Variations() {
 172         TopicPropertyBuilder builder = makePropBuilder().makeTopic(MY_TOPIC);
 173
 174         // null sinks
 175         Properties props = builder.build();
 176         props.remove(PROPERTY_DMAAP_SINK_TOPICS);
 177         assertTrue(factory.build(props).isEmpty());
 178
 179         // empty sinks
 180         props = builder.build();
 181         props.setProperty(PROPERTY_DMAAP_SINK_TOPICS, "");
 182         assertTrue(factory.build(props).isEmpty());
 183
 184         // null servers
 185         assertTrue(factory.build(makePropBuilder().makeTopic(MY_TOPIC)
 186                         .removeTopicProperty(PROPERTY_TOPIC_SERVERS_SUFFIX).build()).isEmpty());
 187
 188         // empty servers
 189         assertTrue(factory.build(makePropBuilder().makeTopic(MY_TOPIC)
 190                         .removeTopicProperty(PROPERTY_TOPIC_SERVERS_SUFFIX).build()).isEmpty());
 191
 192         // check boolean properties that default to true
 193         checkDefault(builder, PROPERTY_MANAGED_SUFFIX, BusTopicParams::isManaged);
 194
 195         // check boolean properties that default to false
 196         checkDefault(builder, PROPERTY_HTTP_HTTPS_SUFFIX, params -> ! params.isUseHttps());
 197         checkDefault(builder, PROPERTY_ALLOW_SELF_SIGNED_CERTIFICATES_SUFFIX,
 198             params -> ! params.isAllowSelfSignedCerts());
 199
 200         // check "additional" properties
 201         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_EP_CONN_TIMEOUT_SUFFIX,
 202                         DmaapTopicSinkFactory.DME2_EP_CONN_TIMEOUT_PROPERTY);
 203
 204         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_EP_READ_TIMEOUT_MS_SUFFIX,
 205                         DmaapTopicSinkFactory.DME2_READ_TIMEOUT_PROPERTY);
 206
 207         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_ROUNDTRIP_TIMEOUT_MS_SUFFIX,
 208                         DmaapTopicSinkFactory.DME2_ROUNDTRIP_TIMEOUT_PROPERTY);
 209
 210         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_ROUTE_OFFER_SUFFIX,
 211                         DmaapTopicSinkFactory.DME2_ROUTE_OFFER_PROPERTY);
 212
 213         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_SESSION_STICKINESS_REQUIRED_SUFFIX,
 214                         DmaapTopicSinkFactory.DME2_SESSION_STICKINESS_REQUIRED_PROPERTY);
 215
 216         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_SUB_CONTEXT_PATH_SUFFIX,
 217                         DmaapTopicSinkFactory.DME2_SUBCONTEXT_PATH_PROPERTY);
 218
 219         expectNullAddProp(builder, PROPERTY_DMAAP_DME2_VERSION_SUFFIX, DmaapTopicSinkFactory.DME2_VERSION_PROPERTY);
 220     }
 221
 222     @Test
 223     public void testBuildProperties_Multiple() {
 224         TopicPropertyBuilder builder =
 225                         makePropBuilder().makeTopic(MY_TOPIC).makeTopic(TOPIC2).addTopic(MY_TOPIC).addTopic(MY_TOPIC);
 226
 227         List<DmaapTopicSink> lst = factory.build(builder.build());
 228         assertEquals(4, lst.size());
 229
 230         int index = 0;
 231         DmaapTopicSink sink = lst.get(index++);
 232         assertTrue(sink != lst.get(index++));
 233         assertTrue(sink == lst.get(index++));
 234         assertTrue(sink == lst.get(index++));
 235     }
 236
 237     @Test
 238     public void testDestroyString_testGet_testInventory() {
 239         List<DmaapTopicSink> lst = factory.build(makePropBuilder().makeTopic(MY_TOPIC).makeTopic(TOPIC2).build());
 240
 241         int index = 0;
 242         DmaapTopicSink sink1 = lst.get(index++);
 243         DmaapTopicSink sink2 = lst.get(index++);
 244
 245         assertEquals(2, factory.inventory().size());
 246         assertTrue(factory.inventory().contains(sink1));
 247         assertTrue(factory.inventory().contains(sink2));
 248
 249         sink1.start();
 250         sink2.start();
 251
 252         assertEquals(sink1, factory.get(MY_TOPIC));
 253         assertEquals(sink2, factory.get(TOPIC2));
 254
 255         factory.destroy(MY_TOPIC);
 256         assertFalse(sink1.isAlive());
 257         assertTrue(sink2.isAlive());
 258         assertEquals(sink2, factory.get(TOPIC2));
 259         assertEquals(1, factory.inventory().size());
 260         assertTrue(factory.inventory().contains(sink2));
 261
 262         // repeat
 263         factory.destroy(MY_TOPIC);
 264         assertFalse(sink1.isAlive());
 265         assertTrue(sink2.isAlive());
 266
 267         // with other topic
 268         factory.destroy(TOPIC2);
 269         assertFalse(sink1.isAlive());
 270         assertFalse(sink2.isAlive());
 271         assertEquals(0, factory.inventory().size());
 272     }
 273
 274     @Test(expected = IllegalArgumentException.class)
 275     public void testDestroyString_NullTopic() {
 276         factory.destroy(null);
 277     }
 278
 279     @Test(expected = IllegalArgumentException.class)
 280     public void testDestroyString_EmptyTopic() {
 281         factory.destroy("");
 282     }
 283
 284     @Test
 285     public void testDestroy() {
 286         List<DmaapTopicSink> lst = factory.build(makePropBuilder().makeTopic(MY_TOPIC).makeTopic(TOPIC2).build());
 287
 288         int index = 0;
 289         DmaapTopicSink sink1 = lst.get(index++);
 290         DmaapTopicSink sink2 = lst.get(index++);
 291
 292         sink1.start();
 293         sink2.start();
 294
 295         factory.destroy();
 296         assertFalse(sink1.isAlive());
 297         assertFalse(sink2.isAlive());
 298         assertEquals(0, factory.inventory().size());
 299     }
 300
 301     @Test(expected = IllegalArgumentException.class)
 302     public void testGet_NullTopic() {
 303         factory.get(null);
 304     }
 305
 306     @Test(expected = IllegalArgumentException.class)
 307     public void testGet_EmptyTopic() {
 308         factory.get("");
 309     }
 310
 311     @Test(expected = IllegalArgumentException.class)
 312     public void testGet_UnknownTopic() {
 313         factory.build(makePropBuilder().makeTopic(MY_TOPIC).build());
 314         factory.get(TOPIC2);
 315     }
 316
 317     @Test
 318     public void testToString() {
 319         assertTrue(factory.toString().startsWith("IndexedDmaapTopicSinkFactory ["));
 320     }
 321
 322     private DmaapTopicPropertyBuilder makePropBuilder() {
 323         return new DmaapTopicPropertyBuilder(PROPERTY_DMAAP_SINK_TOPICS);
 324     }
 325
 326     /**
 327      * Verifies that a parameter has the correct default, if the original builder property
 328      * is not provided.
 329      *
 330      * @param builder used to build a set of properties
 331      * @param builderName name of the builder property
 332      * @param getter function to get the property from a set of parameters
 333      */
 334     private void checkDefault(TopicPropertyBuilder builder, String builderName,
 335                     Function<BusTopicParams, Boolean> getter) {
 336
 337         /*
 338          * Not sure why the "managed" property is treated differently, but it is.
 339          */
 340         String prefix = PROPERTY_DMAAP_SINK_TOPICS + "." + MY_TOPIC;
 341
 342         // always start with a fresh factory
 343         factory.destroy();
 344         factory = new SinkFactory();
 345
 346         Properties props = builder.build();
 347         props.remove(prefix + builderName);
 348
 349         assertEquals(1, factory.build(props).size());
 350         assertTrue(getter.apply(factory.params.get(0)));
 351
 352         // repeat, this time using an empty string instead of null
 353         factory.destroy();
 354         factory = new SinkFactory();
 355
 356         props.setProperty(prefix + builderName, "");
 357
 358         assertEquals(1, factory.build(props).size());
 359         assertTrue(getter.apply(factory.params.get(0)));
 360     }
 361
 362     /**
 363      * Verifies that an "additional" property does not exist, if the original builder
 364      * property is not provided.
 365      *
 366      * @param builder used to build a set of properties
 367      * @param builderName name of the builder property
 368      * @param addName name of the "additional" property
 369      */
 370     private void expectNullAddProp(TopicPropertyBuilder builder, String builderName, String addName) {
 371         // always start with a fresh factory
 372         factory.destroy();
 373         factory = new SinkFactory();
 374
 375         Properties props = builder.build();
 376         props.remove(PROPERTY_DMAAP_SINK_TOPICS + "." + MY_TOPIC + builderName);
 377
 378         assertEquals(1, factory.build(props).size());
 379         assertFalse(factory.params.get(0).getAdditionalProps().containsKey(addName));
 380
 381         // repeat, this time using an empty string instead of null
 382         factory.destroy();
 383         factory = new SinkFactory();
 384
 385         props.setProperty(PROPERTY_DMAAP_SINK_TOPICS + "." + MY_TOPIC + builderName, "");
 386
 387         assertEquals(1, factory.build(props).size());
 388         assertFalse(factory.params.get(0).getAdditionalProps().containsKey(addName));
 389     }
 390
 391     /**
 392      * Factory that records the parameters of all of the sinks it creates.
 393      */
 394     private static class SinkFactory extends IndexedDmaapTopicSinkFactory {
 395         private List<BusTopicParams> params = new LinkedList<>();
 396
 397         @Override
 398         protected DmaapTopicSink makeSink(BusTopicParams busTopicParams) {
 399             params.add(busTopicParams);
 400             return super.makeSink(busTopicParams);
 401         }
 402     }
 403 }