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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2024 Nordix Foundation.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.common.endpoints.event.comm;
  23
  24 import static org.assertj.core.api.Assertions.assertThatCode;
  25 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
  26 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertFalse;
  29 import static org.junit.Assert.assertSame;
  30 import static org.junit.Assert.assertTrue;
  31
  32 import java.util.LinkedList;
  33 import java.util.List;
  34 import java.util.Properties;
  35 import org.junit.After;
  36 import org.junit.Test;
  37 import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;
  38 import org.onap.policy.common.endpoints.event.comm.bus.NoopTopicFactories;
  39 import org.onap.policy.common.endpoints.event.comm.bus.NoopTopicPropertyBuilder;
  40 import org.onap.policy.common.endpoints.event.comm.bus.UebTopicFactories;
  41 import org.onap.policy.common.endpoints.event.comm.bus.UebTopicPropertyBuilder;
  42 import org.onap.policy.common.endpoints.parameters.TopicParameterGroup;
  43 import org.onap.policy.common.endpoints.parameters.TopicParameters;
  44 import org.onap.policy.common.endpoints.properties.PolicyEndPointProperties;
  45 import org.onap.policy.common.utils.gson.GsonTestUtils;
  46
  47 public class TopicEndpointProxyTest {
  48
  49     private static final String NOOP_SOURCE_TOPIC = "noop-source";
  50     private static final String NOOP_SINK_TOPIC = "noop-sink";
  51
  52     private static final String UEB_SOURCE_TOPIC = "ueb-source";
  53     private static final String UEB_SINK_TOPIC = "ueb-sink";
  54
  55     private Properties configuration = new Properties();
  56     private TopicParameterGroup group = new TopicParameterGroup();
  57
  58     /**
  59      * Constructor.
  60      */
  61     public TopicEndpointProxyTest() {
  62         group.setTopicSinks(new LinkedList<>());
  63         group.setTopicSources(new LinkedList<>());
  64
  65         NoopTopicPropertyBuilder noopSourceBuilder =
  66                 new NoopTopicPropertyBuilder(PolicyEndPointProperties.PROPERTY_NOOP_SOURCE_TOPICS)
  67                         .makeTopic(NOOP_SOURCE_TOPIC);
  68         configuration.putAll(noopSourceBuilder.build());
  69         group.getTopicSources().add(noopSourceBuilder.getParams());
  70
  71         NoopTopicPropertyBuilder noopSinkBuilder =
  72                 new NoopTopicPropertyBuilder(PolicyEndPointProperties.PROPERTY_NOOP_SINK_TOPICS)
  73                         .makeTopic(NOOP_SINK_TOPIC);
  74         configuration.putAll(noopSinkBuilder.build());
  75         group.getTopicSinks().add(noopSinkBuilder.getParams());
  76
  77         UebTopicPropertyBuilder uebSourceBuilder =
  78                 new UebTopicPropertyBuilder(PolicyEndPointProperties.PROPERTY_UEB_SOURCE_TOPICS)
  79                         .makeTopic(UEB_SOURCE_TOPIC);
  80         configuration.putAll(uebSourceBuilder.build());
  81         group.getTopicSources().add(uebSourceBuilder.getParams());
  82
  83         UebTopicPropertyBuilder uebSinkBuilder =
  84                 new UebTopicPropertyBuilder(PolicyEndPointProperties.PROPERTY_UEB_SINK_TOPICS)
  85                         .makeTopic(UEB_SINK_TOPIC);
  86         configuration.putAll(uebSinkBuilder.build());
  87         group.getTopicSinks().add(uebSinkBuilder.getParams());
  88
  89         TopicParameters invalidCommInfraParams =
  90                 new NoopTopicPropertyBuilder(PolicyEndPointProperties.PROPERTY_NOOP_SOURCE_TOPICS)
  91                         .makeTopic(NOOP_SOURCE_TOPIC).getParams();
  92         invalidCommInfraParams.setTopicCommInfrastructure(Topic.CommInfrastructure.REST.name());
  93         group.getTopicSources().add(invalidCommInfraParams);
  94         group.getTopicSinks().add(invalidCommInfraParams);
  95     }
  96
  97     private <T extends Topic> boolean exists(List<T> topics, String topicName) {
  98         return topics.stream().map(Topic::getTopic).anyMatch(topicName::equals);
  99     }
 100
 101     private <T extends Topic> boolean allSources(List<T> topics) {
 102         return exists(topics, NOOP_SOURCE_TOPIC) && exists(topics, UEB_SOURCE_TOPIC);
 103     }
 104
 105     private <T extends Topic> boolean allSinks(List<T> topics) {
 106         return exists(topics, NOOP_SINK_TOPIC) && exists(topics, UEB_SINK_TOPIC);
 107     }
 108
 109     private <T extends Topic> boolean anySource(List<T> topics) {
 110         return exists(topics, NOOP_SOURCE_TOPIC) || exists(topics, UEB_SOURCE_TOPIC);
 111     }
 112
 113     private <T extends Topic> boolean anySink(List<T> topics) {
 114         return exists(topics, NOOP_SINK_TOPIC) || exists(topics, UEB_SINK_TOPIC);
 115     }
 116
 117     /**
 118      * Destroys all managed topics.
 119      */
 120     @After
 121     public void tearDown() {
 122         NoopTopicFactories.getSinkFactory().destroy();
 123         NoopTopicFactories.getSourceFactory().destroy();
 124
 125         UebTopicFactories.getSinkFactory().destroy();
 126         UebTopicFactories.getSourceFactory().destroy();
 127     }
 128
 129     @Test
 130     public void testSerialize() {
 131         TopicEndpoint manager = new TopicEndpointProxy();
 132
 133         manager.addTopicSources(configuration);
 134         manager.addTopicSinks(configuration);
 135
 136         assertThatCode(() -> new GsonTestUtils().compareGson(manager, TopicEndpointProxyTest.class))
 137                 .doesNotThrowAnyException();
 138     }
 139
 140     @Test
 141     public void testAddTopicSourcesListOfTopicParameters() {
 142         TopicEndpoint manager = new TopicEndpointProxy();
 143
 144         List<TopicSource> sources = manager.addTopicSources(group.getTopicSources());
 145         assertSame(2, sources.size());
 146
 147         assertTrue(allSources(sources));
 148         assertFalse(anySink(sources));
 149     }
 150
 151     @Test
 152     public void testAddTopicSourcesProperties() {
 153         TopicEndpoint manager = new TopicEndpointProxy();
 154
 155         List<TopicSource> sources = manager.addTopicSources(configuration);
 156         assertSame(2, sources.size());
 157
 158         assertTrue(allSources(sources));
 159         assertFalse(anySink(sources));
 160     }
 161
 162     @Test
 163     public void testAddTopicSinksListOfTopicParameters() {
 164         TopicEndpoint manager = new TopicEndpointProxy();
 165
 166         List<TopicSink> sinks = manager.addTopicSinks(group.getTopicSinks());
 167         assertSame(2, sinks.size());
 168
 169         assertFalse(anySource(sinks));
 170         assertTrue(allSinks(sinks));
 171     }
 172
 173     @Test
 174     public void testAddTopicSinksProperties() {
 175         TopicEndpoint manager = new TopicEndpointProxy();
 176
 177         List<TopicSink> sinks = manager.addTopicSinks(configuration);
 178         assertSame(2, sinks.size());
 179
 180         assertFalse(anySource(sinks));
 181         assertTrue(allSinks(sinks));
 182     }
 183
 184     @Test
 185     public void testAddTopicsProperties() {
 186         TopicEndpoint manager = new TopicEndpointProxy();
 187
 188         List<Topic> topics = manager.addTopics(configuration);
 189         assertSame(4, topics.size());
 190
 191         assertTrue(allSources(topics));
 192         assertTrue(allSinks(topics));
 193     }
 194
 195     @Test
 196     public void testAddTopicsTopicParameterGroup() {
 197         TopicEndpoint manager = new TopicEndpointProxy();
 198
 199         List<Topic> topics = manager.addTopics(group);
 200         assertSame(4, topics.size());
 201
 202         assertTrue(allSources(topics));
 203         assertTrue(allSinks(topics));
 204     }
 205
 206     @Test
 207     public void testAddTopicsTopicParameterGroupNull() {
 208         TopicEndpoint manager = new TopicEndpointProxy();
 209
 210         List<Topic> topics = manager.addTopics(new TopicParameterGroup());
 211         assertEquals(0, topics.size());
 212     }
 213
 214     @Test
 215     public void testLockSinks_lockSources_locked() {
 216         TopicEndpoint manager = new TopicEndpointProxy();
 217         manager.lock();
 218         for (Topic topic : manager.addTopics(group)) {
 219             assertTrue(topic.isLocked());
 220         }
 221     }
 222
 223     @Test
 224     public void testLockSinks_lockSources_unlocked() {
 225         TopicEndpoint manager = new TopicEndpointProxy();
 226         for (Topic topic : manager.addTopics(group)) {
 227             assertFalse(topic.isLocked());
 228         }
 229     }
 230
 231     @Test
 232     public void testGetTopicSources() {
 233         TopicEndpoint manager = new TopicEndpointProxy();
 234
 235         manager.addTopicSources(configuration);
 236         manager.addTopicSinks(configuration);
 237
 238         List<TopicSource> sources = manager.getTopicSources();
 239         assertSame(2, sources.size());
 240
 241         assertTrue(allSources(sources));
 242         assertFalse(anySink(sources));
 243     }
 244
 245     @Test
 246     public void testGetTopicSinks() {
 247         TopicEndpoint manager = new TopicEndpointProxy();
 248
 249         manager.addTopicSources(configuration);
 250         manager.addTopicSinks(configuration);
 251
 252         List<TopicSink> sinks = manager.getTopicSinks();
 253         assertSame(2, sinks.size());
 254
 255         assertFalse(anySource(sinks));
 256         assertTrue(allSinks(sinks));
 257     }
 258
 259     @Test
 260     public void testGetUebTopicSources() {
 261         TopicEndpoint manager = new TopicEndpointProxy();
 262
 263         manager.addTopicSources(configuration);
 264         assertSame(1, manager.getUebTopicSources().size());
 265     }
 266
 267     @Test
 268     public void testGetNoopTopicSources() {
 269         TopicEndpoint manager = new TopicEndpointProxy();
 270
 271         manager.addTopicSources(configuration);
 272         assertSame(1, manager.getNoopTopicSources().size());
 273     }
 274
 275     @Test
 276     public void testGetUebTopicSinks() {
 277         TopicEndpoint manager = new TopicEndpointProxy();
 278
 279         manager.addTopicSinks(configuration);
 280         assertSame(1, manager.getUebTopicSinks().size());
 281     }
 282
 283     @Test
 284     public void testGetNoopTopicSinks() {
 285         TopicEndpoint manager = new TopicEndpointProxy();
 286
 287         manager.addTopicSinks(configuration);
 288         assertSame(1, manager.getNoopTopicSinks().size());
 289     }
 290
 291     @Test
 292     public void testLifecycle() {
 293         TopicEndpoint manager = new TopicEndpointProxy();
 294
 295         assertTrue(manager.start());
 296         assertTrue(manager.isAlive());
 297
 298         assertTrue(manager.stop());
 299         assertFalse(manager.isAlive());
 300
 301         assertTrue(manager.start());
 302         assertTrue(manager.isAlive());
 303
 304         manager.shutdown();
 305         assertFalse(manager.isAlive());
 306     }
 307
 308     @Test
 309     public void testLock() {
 310         TopicEndpoint manager = new TopicEndpointProxy();
 311
 312         manager.lock();
 313         assertTrue(manager.isLocked());
 314
 315         manager.unlock();
 316         assertFalse(manager.isLocked());
 317     }
 318
 319     @Test
 320     public void testGetTopicSource() {
 321         TopicEndpoint manager = new TopicEndpointProxy();
 322         manager.addTopicSources(configuration);
 323
 324         assertSame(NOOP_SOURCE_TOPIC, manager.getTopicSource(CommInfrastructure.NOOP, NOOP_SOURCE_TOPIC).getTopic());
 325         assertSame(UEB_SOURCE_TOPIC, manager.getTopicSource(CommInfrastructure.UEB, UEB_SOURCE_TOPIC).getTopic());
 326
 327         assertThatIllegalStateException()
 328                 .isThrownBy(() -> manager.getTopicSource(CommInfrastructure.NOOP, NOOP_SINK_TOPIC));
 329         assertThatIllegalStateException()
 330                 .isThrownBy(() -> manager.getTopicSource(CommInfrastructure.UEB, UEB_SINK_TOPIC));
 331     }
 332
 333     @Test
 334     public void testGetTopicSink() {
 335         TopicEndpoint manager = new TopicEndpointProxy();
 336         manager.addTopicSinks(configuration);
 337
 338         assertSame(NOOP_SINK_TOPIC, manager.getTopicSink(CommInfrastructure.NOOP, NOOP_SINK_TOPIC).getTopic());
 339         assertSame(UEB_SINK_TOPIC, manager.getTopicSink(CommInfrastructure.UEB, UEB_SINK_TOPIC).getTopic());
 340
 341         assertThatIllegalStateException()
 342                 .isThrownBy(() -> manager.getTopicSink(CommInfrastructure.NOOP, NOOP_SOURCE_TOPIC));
 343         assertThatIllegalStateException()
 344                 .isThrownBy(() -> manager.getTopicSink(CommInfrastructure.UEB, UEB_SOURCE_TOPIC));
 345     }
 346
 347     @Test
 348     public void testGetUebTopicSource() {
 349         TopicEndpoint manager = new TopicEndpointProxy();
 350         manager.addTopicSources(configuration);
 351
 352         assertSame(UEB_SOURCE_TOPIC, manager.getUebTopicSource(UEB_SOURCE_TOPIC).getTopic());
 353
 354         assertThatIllegalStateException().isThrownBy(() -> manager.getUebTopicSource(NOOP_SOURCE_TOPIC));
 355
 356         assertThatIllegalArgumentException().isThrownBy(() -> manager.getUebTopicSource(null));
 357         assertThatIllegalArgumentException().isThrownBy(() -> manager.getUebTopicSource(""));
 358     }
 359
 360     @Test
 361     public void testGetUebTopicSink() {
 362         TopicEndpoint manager = new TopicEndpointProxy();
 363         manager.addTopicSinks(configuration);
 364
 365         assertSame(UEB_SINK_TOPIC, manager.getUebTopicSink(UEB_SINK_TOPIC).getTopic());
 366
 367         assertThatIllegalStateException().isThrownBy(() -> manager.getUebTopicSink(NOOP_SINK_TOPIC));
 368
 369         assertThatIllegalArgumentException().isThrownBy(() -> manager.getUebTopicSink(null));
 370         assertThatIllegalArgumentException().isThrownBy(() -> manager.getUebTopicSink(""));
 371     }
 372
 373     @Test
 374     public void testGetNoopTopicSource() {
 375         TopicEndpoint manager = new TopicEndpointProxy();
 376         manager.addTopicSources(configuration);
 377
 378         assertSame(NOOP_SOURCE_TOPIC, manager.getNoopTopicSource(NOOP_SOURCE_TOPIC).getTopic());
 379
 380         assertThatIllegalStateException().isThrownBy(() -> manager.getNoopTopicSource(UEB_SOURCE_TOPIC));
 381
 382         assertThatIllegalArgumentException().isThrownBy(() -> manager.getNoopTopicSource(null));
 383         assertThatIllegalArgumentException().isThrownBy(() -> manager.getNoopTopicSource(""));
 384     }
 385
 386     @Test
 387     public void testGetNoopTopicSink() {
 388         TopicEndpoint manager = new TopicEndpointProxy();
 389         manager.addTopicSinks(configuration);
 390
 391         assertSame(NOOP_SINK_TOPIC, manager.getNoopTopicSink(NOOP_SINK_TOPIC).getTopic());
 392
 393         assertThatIllegalStateException().isThrownBy(() -> manager.getNoopTopicSink(UEB_SINK_TOPIC));
 394
 395         assertThatIllegalArgumentException().isThrownBy(() -> manager.getNoopTopicSink(null));
 396         assertThatIllegalArgumentException().isThrownBy(() -> manager.getNoopTopicSink(""));
 397     }
 398 }