gerrit.o-ran-sc Code Review - smo/teiv.git/blob

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024 Ericsson
   4  *  Modifications Copyright (C) 2024 OpenInfra Foundation Europe
   5  *  ================================================================================
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21 package org.oran.smo.teiv.pgsqlgenerator.schema.data;
  22
  23 import java.lang.reflect.Constructor;
  24 import java.lang.reflect.InvocationTargetException;
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.List;
  28
  29 import org.junit.jupiter.api.Assertions;
  30 import org.junit.jupiter.api.BeforeEach;
  31 import org.junit.jupiter.api.Test;
  32 import org.mockito.MockitoAnnotations;
  33 import org.springframework.beans.factory.annotation.Autowired;
  34 import org.springframework.boot.test.context.SpringBootTest;
  35
  36 import org.oran.smo.teiv.pgsqlgenerator.Attribute;
  37 import org.oran.smo.teiv.pgsqlgenerator.Column;
  38 import org.oran.smo.teiv.pgsqlgenerator.Entity;
  39 import org.oran.smo.teiv.pgsqlgenerator.UniqueConstraint;
  40 import org.oran.smo.teiv.pgsqlgenerator.PrimaryKeyConstraint;
  41 import org.oran.smo.teiv.pgsqlgenerator.ForeignKeyConstraint;
  42 import org.oran.smo.teiv.pgsqlgenerator.Relationship;
  43 import org.oran.smo.teiv.pgsqlgenerator.Table;
  44 import org.oran.smo.teiv.pgsqlgenerator.TestHelper;
  45 import org.oran.smo.teiv.pgsqlgenerator.schema.model.HashInfoDataGenerator;
  46 import lombok.extern.slf4j.Slf4j;
  47
  48 import static org.oran.smo.teiv.pgsqlgenerator.Constants.CLASSIFIERS;
  49 import static org.oran.smo.teiv.pgsqlgenerator.Constants.DECORATORS;
  50 import static org.oran.smo.teiv.pgsqlgenerator.Constants.JSONB;
  51
  52 @Slf4j
  53 @SpringBootTest(classes = { TableBuilder.class, HashInfoDataGenerator.class })
  54 class TableBuilderTest {
  55     @Autowired
  56     private TableBuilder tableBuilder;
  57
  58     @BeforeEach
  59     void setUp() {
  60
  61         //mocks
  62         MockitoAnnotations.openMocks(this);
  63
  64     }
  65
  66     //spotless:off
  67     List<Entity> entities = List.of(
  68             Entity.builder().entityName("Sector").attributes(
  69                 List.of(
  70                     Attribute.builder().name("azimuth").dataType("DECIMAL").build(),
  71                     Attribute.builder().name("id").dataType("VARCHAR(511)").constraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
  72                             .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
  73                     Attribute.builder().name("geo-location").dataType("geography").build(),
  74                     Attribute.builder().name("sectorId").dataType("jsonb").build()))
  75                 .moduleReferenceName("").build(),
  76
  77             Entity.builder().entityName("Namespace").attributes(
  78                 List.of(
  79                     Attribute.builder().name("id").dataType("VARCHAR(511)").constraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Namespace_id")
  80                             .tableName("Namespace").columnToAddConstraintTo("id").build())).build(),
  81                     Attribute.builder().name("name").dataType("TEXT").build()))
  82                 .moduleReferenceName("").build());
  83
  84     List<List<Relationship>> relationships = List.of(
  85             List.of(Relationship.builder().name("oneToOne")
  86                     .aSideAssociationName("used-Sector")
  87                     .aSideMOType("Sector")
  88                     .aSideMinCardinality(0)
  89                     .aSideMaxCardinality(1)
  90                     .bSideAssociationName("used-by-Namespace")
  91                     .bSideMOType("Namespace")
  92                     .bSideMinCardinality(0)
  93                     .bSideMaxCardinality(1)
  94                     .relationshipDataLocation("A_SIDE")
  95                     .associationKind("BI_DIRECTIONAL")
  96                     .connectSameEntity(false)
  97                     .moduleReferenceName("").build()),
  98             List.of(Relationship.builder().name("oneToMany")
  99                     .aSideAssociationName("used-Sector")
 100                     .aSideMOType("Sector")
 101                     .aSideMinCardinality(0)
 102                     .aSideMaxCardinality(1)
 103                     .bSideAssociationName("used-by-Namespace")
 104                     .bSideMOType("Namespace")
 105                     .bSideMinCardinality(0)
 106                     .bSideMaxCardinality(100)
 107                     .relationshipDataLocation("B_SIDE")
 108                     .associationKind("BI_DIRECTIONAL")
 109                     .connectSameEntity(false)
 110                     .moduleReferenceName("").build()),
 111             List.of(Relationship.builder().name("manyToOne")
 112                     .aSideAssociationName("used-Sector")
 113                     .aSideMOType("Sector")
 114                     .aSideMinCardinality(0)
 115                     .aSideMaxCardinality(100)
 116                     .bSideAssociationName("used-by-Namespace")
 117                     .bSideMOType("Namespace")
 118                     .bSideMinCardinality(0)
 119                     .bSideMaxCardinality(1)
 120                     .relationshipDataLocation("A_SIDE")
 121                     .associationKind("BI_DIRECTIONAL")
 122                     .connectSameEntity(false)
 123                     .moduleReferenceName("").build()),
 124             List.of(Relationship.builder().name("manyToMany")
 125                     .aSideAssociationName("used-Sector")
 126                     .aSideMOType("Sector")
 127                     .aSideMinCardinality(0)
 128                     .aSideMaxCardinality(100)
 129                     .bSideAssociationName("used-by-Namespace")
 130                     .bSideMOType("Namespace")
 131                     .bSideMinCardinality(0)
 132                     .bSideMaxCardinality(100)
 133                     .relationshipDataLocation("RELATION")
 134                     .associationKind("BI_DIRECTIONAL")
 135                     .connectSameEntity(false)
 136                     .moduleReferenceName("").build()),
 137             // Relationship connecting same entity 1:1
 138             List.of(Relationship.builder().name("relationshipConnectingSameEntity")
 139                     .aSideAssociationName("used-Sector")
 140                     .aSideMOType("Sector")
 141                     .aSideMinCardinality(0)
 142                     .aSideMaxCardinality(1)
 143                     .bSideAssociationName("used-by-Sector")
 144                     .bSideMOType("Sector")
 145                     .bSideMinCardinality(0)
 146                     .bSideMaxCardinality(1)
 147                     .relationshipDataLocation("RELATION")
 148                     .associationKind("BI_DIRECTIONAL")
 149                     .connectSameEntity(true)
 150                     .moduleReferenceName("").build()),
 151             // Relationship connecting same entity 1:N
 152             List.of(Relationship.builder().name("relationshipConnectingSameEntity")
 153                     .aSideAssociationName("used-Sector")
 154                     .aSideMOType("Sector")
 155                     .aSideMinCardinality(0)
 156                     .aSideMaxCardinality(1)
 157                     .bSideAssociationName("used-by-Sector")
 158                     .bSideMOType("Sector")
 159                     .bSideMinCardinality(0)
 160                     .bSideMaxCardinality(100)
 161                     .relationshipDataLocation("RELATION")
 162                     .associationKind("BI_DIRECTIONAL")
 163                     .connectSameEntity(true)
 164                     .moduleReferenceName("").build()),
 165             // Relationship connecting same entity N:1
 166             List.of(Relationship.builder().name("relationshipConnectingSameEntity")
 167                     .aSideAssociationName("used-Sector")
 168                     .aSideMOType("Sector")
 169                     .aSideMinCardinality(0)
 170                     .aSideMaxCardinality(100)
 171                     .bSideAssociationName("used-by-Sector")
 172                     .bSideMOType("Sector")
 173                     .bSideMinCardinality(0)
 174                     .bSideMaxCardinality(1)
 175                     .relationshipDataLocation("RELATION")
 176                     .associationKind("BI_DIRECTIONAL")
 177                     .connectSameEntity(true)
 178                     .moduleReferenceName("").build()),
 179             // Relationship connecting same entity N:M
 180             List.of(Relationship.builder().name("relationshipConnectingSameEntity")
 181                     .aSideAssociationName("used-Sector")
 182                     .aSideMOType("Sector")
 183                     .aSideMinCardinality(0)
 184                     .aSideMaxCardinality(100)
 185                     .bSideAssociationName("used-by-Sector")
 186                     .bSideMOType("Sector")
 187                     .bSideMinCardinality(0)
 188                     .bSideMaxCardinality(100)
 189                     .relationshipDataLocation("RELATION")
 190                     .associationKind("BI_DIRECTIONAL")
 191                     .connectSameEntity(true)
 192                     .moduleReferenceName("").build()));
 193     //spotless:on
 194
 195     @Test
 196     void checkOneToOneRelationshipMappingTest() {
 197
 198         //spotless:off
 199
 200         // Given
 201         List<Table> expectedResult = List.of(Table.builder().name("Sector").columns(
 202             List.of(
 203                 Column.builder().name("azimuth").dataType("DECIMAL").build(),
 204                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 205                         .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 206                 Column.builder().name("sectorId").dataType("jsonb").build(),
 207                 Column.builder().name("geo-location").dataType("geography").build(),
 208                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 209                 Column.builder().name("REL_FK_used-Sector").dataType("VARCHAR(511)")
 210                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_Sector_REL_FK_used-Sector").tableName("Sector")
 211                                 .referencedTable("Namespace").columnToAddConstraintTo("REL_FK_used-sector").build())).build(),
 212                 Column.builder().name("REL_ID_oneToOne").dataType("VARCHAR(511)")
 213                         .postgresConstraints(List.of(UniqueConstraint.builder().constraintName("UNIQUE_Sector_REL_ID_oneToOne").tableName("Sector")
 214                                 .columnToAddConstraintTo("REL_ID_oneToOne").build())).build(),
 215                 Column.builder().name("REL_CD_sourceIds_oneToOne").dataType("jsonb").defaultValue("[]").build(),
 216                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType(JSONB).defaultValue("[]").build(),
 217                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType(JSONB).defaultValue("{}").build(),
 218                     Column.builder().name(String.format("REL_CD_%s_oneToOne", CLASSIFIERS)).dataType(JSONB).defaultValue("[]").build(),
 219                     Column.builder().name(String.format("REL_CD_%s_oneToOne", DECORATORS)).dataType(JSONB).defaultValue("{}").build())).build(),
 220
 221         Table.builder().name("Namespace").columns(
 222             List.of(
 223                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Namespace_id")
 224                         .tableName("Namespace").columnToAddConstraintTo("id").build())).build(),
 225                 Column.builder().name("name").dataType("TEXT").build(),
 226                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 227                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 228                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build());
 229
 230         //spotless:on
 231
 232         // When
 233         List<Table> actualResult = tableBuilder.getTables(entities, relationships.get(0));
 234
 235         // Then
 236         runTest(actualResult, expectedResult);
 237     }
 238
 239     @Test
 240     void checkOneToManyRelationshipMappingTest() {
 241
 242         //spotless:off
 243
 244         // Given
 245         List<Table> expectedResult = List.of(Table.builder().name("Sector").columns(
 246             List.of(
 247                 Column.builder().name("azimuth").dataType("DECIMAL").build(),
 248                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 249                         .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 250                 Column.builder().name("sectorId").dataType("jsonb").build(),
 251                 Column.builder().name("geo-location").dataType("geography").build(),
 252                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 253                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 254                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build(),
 255
 256         Table.builder().name("Namespace").columns(
 257             List.of(
 258                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Namespace_id")
 259                         .tableName("Namespace").columnToAddConstraintTo("id").build())).build(),
 260                 Column.builder().name("name").dataType("TEXT").build(),
 261                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 262                 Column.builder().name("REL_FK_used-by-Namespace").dataType("VARCHAR(511)")
 263                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_Namespace_REL_FK_used-by-Namespace")
 264                                 .tableName("Namespace").referencedTable("Sector").columnToAddConstraintTo("REL_FK_used-by-Namespace").build())).build(),
 265                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 266                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build(),
 267                 Column.builder().name("REL_ID_oneToMany").dataType("VARCHAR(511)")
 268                         .postgresConstraints(List.of(UniqueConstraint.builder().constraintName("UNIQUE_Namespace_REL_ID_oneToMany").tableName("Namespace")
 269                                 .columnToAddConstraintTo("REL_ID_oneToMany").build())).build(),
 270                 Column.builder().name("REL_CD_sourceIds_oneToMany").dataType("jsonb").defaultValue("[]").build(),
 271                 Column.builder().name(String.format("REL_CD_%s_oneToMany", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 272                 Column.builder().name(String.format("REL_CD_%s_oneToMany", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build());
 273         //spotless:on
 274
 275         // When
 276         List<Table> actualResult = tableBuilder.getTables(entities, relationships.get(1));
 277
 278         // Then
 279         runTest(actualResult, expectedResult);
 280
 281     }
 282
 283     @Test
 284     void checkManyToOneRelationshipMappingTest() {
 285
 286         //spotless:off
 287
 288         // Given
 289         List<Table> expectedResult = List.of(Table.builder().name("Sector").columns(
 290             List.of(
 291                 Column.builder().name("azimuth").dataType("DECIMAL").build(),
 292                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 293                         .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 294                 Column.builder().name("sectorId").dataType("jsonb").build(),
 295                 Column.builder().name("geo-location").dataType("geography").build(),
 296                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 297                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 298                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build(),
 299                 Column.builder().name("REL_FK_used-Sector").dataType("VARCHAR(511)")
 300                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_Sector_REL_FK_used-Sector").tableName("Sector")
 301                                 .referencedTable("Namespace").columnToAddConstraintTo("REL_FK_used-sector").build())).build(),
 302                 Column.builder().name("REL_ID_manyToOne").dataType("VARCHAR(511)")
 303                         .postgresConstraints(List.of(UniqueConstraint.builder().constraintName("UNIQUE_Sector_REL_ID_manyToOne").tableName("Sector")
 304                                 .columnToAddConstraintTo("REL_ID_oneToOne").build())).build(),
 305                 Column.builder().name("REL_CD_sourceIds_manyToOne").dataType("jsonb").defaultValue("[]").build(),
 306                     Column.builder().name(String.format("REL_CD_%s_manyToOne", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 307                     Column.builder().name(String.format("REL_CD_%s_manyToOne", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build(),
 308
 309         Table.builder().name("Namespace").columns(
 310             List.of(
 311                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Namespace_id")
 312                         .tableName("Namespace").columnToAddConstraintTo("id").build())).build(),
 313                 Column.builder().name("name").dataType("TEXT").build(),
 314                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 315                     Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 316                     Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build());
 317         //spotless:on
 318
 319         // When
 320         List<Table> actualResult = tableBuilder.getTables(entities, relationships.get(2));
 321
 322         // Then
 323         runTest(actualResult, expectedResult);
 324
 325     }
 326
 327     @Test
 328     void checkManyToManyRelationshipMappingTest() {
 329         //spotless:off
 330         // Given
 331         List<Table> expectedResult = List.of(Table.builder().name("Sector").columns(
 332             List.of(
 333                 Column.builder().name("azimuth").dataType("DECIMAL").build(),
 334                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 335                         .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 336                 Column.builder().name("sectorId").dataType("jsonb").build(),
 337                 Column.builder().name("geo-location").dataType("geography").build(),
 338                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 339                     Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 340                     Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build(),
 341
 342         Table.builder().name("Namespace").columns(
 343             List.of(
 344                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Namespace_id")
 345                         .tableName("Namespace").columnToAddConstraintTo("id").build())).build(),
 346                 Column.builder().name("name").dataType("TEXT").build(),
 347                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 348                     Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 349                     Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build(),
 350
 351         Table.builder().name("manyToMany").columns(
 352             List.of(
 353                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_manyToMany_id")
 354                         .tableName("manyToMany").columnToAddConstraintTo("id").build())).build(),
 355                 Column.builder().name("aSide_Sector").dataType("VARCHAR(511)")
 356                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_manyToMany_aSide_Sector")
 357                                 .tableName("manyToMany").referencedTable("Sector").columnToAddConstraintTo("aSide_Sector").build())).build(),
 358                 Column.builder().name("bSide_Namespace").dataType("VARCHAR(511)")
 359                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_manyToMany_bSide_Namespace")
 360                                 .tableName("manyToMany").referencedTable("Namespace").columnToAddConstraintTo("bSide_Namespace").build())).build(),
 361                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 362                     Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 363                     Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build());
 364         //spotless:on
 365
 366         // When
 367         List<Table> actualResult = tableBuilder.getTables(entities, relationships.get(3));
 368
 369         // Then
 370         runTest(actualResult, expectedResult);
 371     }
 372
 373     @Test
 374     void checkRelationshipConnectingSameEntityMappingTest() {
 375         //spotless:off
 376         List<Entity> sameEntities = List.of(
 377
 378             Entity.builder().entityName("Sector").attributes(
 379                 List.of(Attribute.builder().name("azimuth").dataType("DECIMAL").build(),
 380                     Attribute.builder().name("id").dataType("VARCHAR(511)").constraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 381                             .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 382                     Attribute.builder().name("sectorId").dataType("jsonb").build(),
 383                     Attribute.builder().name("geo-location").dataType("geography").build()))
 384                 .moduleReferenceName("").build());
 385
 386         // Given
 387         List<Table> expectedResult = List.of(Table.builder().name("Sector").columns(
 388             List.of(
 389                 Column.builder().name("azimuth").dataType("DECIMAL").build(),
 390                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder().constraintName("PK_Sector_id")
 391                         .tableName("Sector").columnToAddConstraintTo("id").build())).build(),
 392                 Column.builder().name("sectorId").dataType("jsonb").build(),
 393                 Column.builder().name("geo-location").dataType("geography").build(),
 394                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 395                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 396                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build(),
 397
 398         Table.builder().name("relationshipConnectingSameEntity").columns(
 399             List.of(
 400                 Column.builder().name("id").dataType("VARCHAR(511)").postgresConstraints(List.of(PrimaryKeyConstraint.builder()
 401                         .constraintName("PK_relationshipConnectingSameEntity_id").tableName("relationshipConnectingSameEntity").columnToAddConstraintTo("id")
 402                         .build())).build(),
 403                 Column.builder().name("aSide_Sector").dataType("VARCHAR(511)")
 404                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_relationshipConnectingSameEntity_aSide_Sector")
 405                                 .tableName("relationshipConnectingSameEntity").referencedTable("Sector").columnToAddConstraintTo("aSide_Sector").build())).build(),
 406                 Column.builder().name("bSide_Sector").dataType("VARCHAR(511)")
 407                         .postgresConstraints(List.of(ForeignKeyConstraint.builder().constraintName("FK_relationshipConnectingSameEntity_bSide_Sector")
 408                                 .tableName("relationshipConnectingSameEntity").referencedTable("Sector").columnToAddConstraintTo("bSide_Sector").build())).build(),
 409                 Column.builder().name("CD_sourceIds").dataType("jsonb").defaultValue("[]").build(),
 410                 Column.builder().name(String.format("CD_%s", CLASSIFIERS)).dataType("jsonb").defaultValue("[]").build(),
 411                 Column.builder().name(String.format("CD_%s", DECORATORS)).dataType("jsonb").defaultValue("{}").build())).build());
 412         //spotless:on
 413
 414         // When
 415         List<Table> actualResultOneToOne = tableBuilder.getTables(sameEntities, relationships.get(4));
 416         List<Table> actualResultOneToMany = tableBuilder.getTables(sameEntities, relationships.get(5));
 417         List<Table> actualResultManyToOne = tableBuilder.getTables(sameEntities, relationships.get(6));
 418         List<Table> actualResultManyToMany = tableBuilder.getTables(sameEntities, relationships.get(7));
 419
 420         // Then
 421         // Test relationship connecting same entity (one to one)
 422         runTest(actualResultOneToOne, expectedResult);
 423
 424         // Test relationship connecting same entity (one to many)
 425         runTest(actualResultOneToMany, expectedResult);
 426
 427         // Test relationship connecting same entity (many to one)
 428         runTest(actualResultManyToOne, expectedResult);
 429
 430         // Test relationship connecting same entity (many to many)
 431         runTest(actualResultManyToMany, expectedResult);
 432
 433     }
 434
 435     void runTest(List<Table> generatedTables, List<Table> expectedTables) {
 436
 437         List<String> allTableNamesFromGeneratedResult = TestHelper.extractTableNames(generatedTables);
 438         List<String> allTableNamesFromExpectedResult = TestHelper.extractTableNames(expectedTables);
 439
 440         // Check if generatedResult contains all tables
 441         Assertions.assertEquals(allTableNamesFromExpectedResult, allTableNamesFromGeneratedResult);
 442
 443         //spotless:off
 444         expectedTables.forEach(expectedTable -> {
 445             generatedTables.stream().filter(generatedTable -> generatedTable.getName().equals(expectedTable.getName())).findFirst()
 446                 .ifPresent(generatedTable -> {
 447                     List<Column> columnsInExpected = expectedTable.getColumns();
 448                     List<Column> columnsInGenerated = generatedTable.getColumns();
 449
 450                     // Check if all columns for each table were added correctly
 451                     Assertions.assertEquals(columnsInExpected.size(), columnsInGenerated.size());
 452
 453                     List<String> allColumnNamesForATableInGeneratedResult = TestHelper.extractColumnNamesForATable(columnsInGenerated);
 454                     List<String> allColumnNamesForATableInExpectedResult = TestHelper.extractColumnNamesForATable(columnsInExpected);
 455
 456                     // Check if generatedResult contains all columns for a table
 457                     Assertions.assertEquals(allColumnNamesForATableInExpectedResult, allColumnNamesForATableInGeneratedResult);
 458
 459                     columnsInExpected.forEach(columnInExpected -> {
 460                         columnsInGenerated.stream().filter(columnInGenerated -> columnInGenerated.getName().equals(columnInExpected.getName()))
 461                             .findFirst().ifPresent(columnInGenerated -> {
 462
 463                                 if (columnInExpected.getName().equals("id")) {
 464                                     Assertions.assertEquals("VARCHAR(511)", columnInGenerated.getDataType());
 465                                     Assertions.assertTrue(TestHelper.checkIfColumnIsPrimaryKey(columnInGenerated.getPostgresConstraints()));
 466                                 }
 467
 468                                 // Check if each attributes' datatype is picked correctly
 469                                 Assertions.assertEquals(columnInExpected.getDataType().replace("\"", ""), columnInGenerated.getDataType());
 470
 471                                 // Check if each attributes' default value is picked correctly
 472                                 Assertions.assertEquals(columnInExpected.getDefaultValue(), columnInGenerated.getDefaultValue());
 473
 474                                 if (!columnInExpected.getPostgresConstraints().isEmpty()) {
 475
 476                                     Assertions.assertEquals(columnInExpected.getPostgresConstraints().size(), columnInGenerated.getPostgresConstraints().size());
 477
 478                                     List<String> expectedConstraintNames = TestHelper.extractConstraintName(columnInExpected.getPostgresConstraints());
 479                                     List<String> actualConstraintNames = TestHelper.extractConstraintName(columnInGenerated.getPostgresConstraints());
 480
 481                                     // Check if constraint names in expected result match with those in actual result
 482                                     Assertions.assertEquals(expectedConstraintNames, actualConstraintNames);
 483
 484                                     columnInExpected.getPostgresConstraints().forEach(constraint -> {
 485                                         columnInGenerated.getPostgresConstraints().stream()
 486                                             .filter(constraint1 -> constraint1.getConstraintName().equals(constraint.getConstraintName())).findFirst()
 487                                             .ifPresent(constraint1 -> {
 488
 489                                                 // Check table name where constraint is to be added
 490                                                 Assertions.assertEquals(constraint.getTableToAddConstraintTo(), constraint.getTableToAddConstraintTo());
 491
 492                                                 // Check column where constraint is to be added
 493                                                 Assertions.assertEquals(constraint.getColumnToAddConstraintTo(), constraint.getColumnToAddConstraintTo());
 494
 495                                                 if (constraint instanceof ForeignKeyConstraint expectedFk) {
 496                                                     ForeignKeyConstraint actualFK = (ForeignKeyConstraint) constraint1;
 497
 498                                                     Assertions.assertEquals(expectedFk.getReferencedTable(), actualFK.getReferencedTable());
 499                                                 }
 500                                             });
 501                                     });
 502                                 }
 503                             });
 504                     });
 505                 });
 506         });
 507         //spotless:on
 508     }
 509
 510     Collection<Object> addEModelPrimaryKeyConstraint() {
 511         Collection<Object> eModelPrimaryKeyConstraint = new ArrayList<>();
 512         try {
 513             Constructor<PrimaryKeyConstraint> constructor = PrimaryKeyConstraint.class.getDeclaredConstructor();
 514             eModelPrimaryKeyConstraint.add(constructor.newInstance());
 515         } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
 516             log.error("Failure in tests --> Error while adding primary key constraint: " + e.getMessage());
 517         }
 518         return eModelPrimaryKeyConstraint;
 519     }
 520
 521 }