git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2023 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.persistence.jdbc.internal;
  14
  15 import static org.hamcrest.MatcherAssert.assertThat;
  16 import static org.hamcrest.core.Is.is;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import org.eclipse.jdt.annotation.NonNullByDefault;
  24 import org.junit.jupiter.api.Assertions;
  25 import org.junit.jupiter.api.BeforeEach;
  26 import org.junit.jupiter.api.Test;
  27 import org.junit.jupiter.api.extension.ExtendWith;
  28 import org.mockito.Mock;
  29 import org.mockito.Mockito;
  30 import org.mockito.junit.jupiter.MockitoExtension;
  31 import org.mockito.junit.jupiter.MockitoSettings;
  32 import org.mockito.quality.Strictness;
  33 import org.openhab.persistence.jdbc.internal.dto.ItemVO;
  34 import org.slf4j.LoggerFactory;
  35
  36 import ch.qos.logback.classic.Level;
  37 import ch.qos.logback.classic.Logger;
  38
  39 /**
  40  * Tests the {@link NamingStrategy} class.
  41  *
  42  * @author Jacob Laursen - Initial contribution
  43  */
  44 @ExtendWith(MockitoExtension.class)
  45 @MockitoSettings(strictness = Strictness.LENIENT)
  46 @NonNullByDefault
  47 public class NamingStrategyTest {
  48     private static final String ITEMS_MANAGE_TABLE_NAME = "items";
  49
  50     private @Mock @NonNullByDefault({}) JdbcConfiguration configurationMock;
  51     private NamingStrategy namingStrategy = new NamingStrategy(configurationMock);
  52
  53     @BeforeEach
  54     public void initialize() {
  55         final Logger logger = (Logger) LoggerFactory.getLogger(NamingStrategy.class);
  56         logger.setLevel(Level.OFF);
  57         namingStrategy = new NamingStrategy(configurationMock);
  58     }
  59
  60     @Test
  61     public void getTableNameWhenInvalidItemNameThrows() {
  62         Assertions.assertThrows(IllegalArgumentException.class, () -> {
  63             namingStrategy.getTableName(1, "4Two");
  64         });
  65     }
  66
  67     @Test
  68     public void getTableNameWhenUseRealItemNamesNameIsLowerCaseAndNumbered() {
  69         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
  70         Mockito.doReturn(false).when(configurationMock).getTableCaseSensitiveItemNames();
  71         assertThat(namingStrategy.getTableName(1, "Test"), is("test_1"));
  72     }
  73
  74     @Test
  75     public void getTableNameWhenUseRealCaseSensitiveItemNamesNameIsSameCase() {
  76         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
  77         Mockito.doReturn(true).when(configurationMock).getTableCaseSensitiveItemNames();
  78         assertThat(namingStrategy.getTableName(1, "Camel"), is("Camel"));
  79     }
  80
  81     @Test
  82     public void getTableNameWhenUseRealCaseSensitiveItemNamesNameIsSameCaseLower() {
  83         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
  84         Mockito.doReturn(true).when(configurationMock).getTableCaseSensitiveItemNames();
  85         assertThat(namingStrategy.getTableName(1, "lower"), is("lower"));
  86     }
  87
  88     @Test
  89     public void getTableNameWhenNotUseRealItemNamesAndCount4NameHasLeavingZeros() {
  90         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
  91         Mockito.doReturn(4).when(configurationMock).getTableIdDigitCount();
  92         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
  93         assertThat(namingStrategy.getTableName(2, "Test"), is("Item0002"));
  94     }
  95
  96     @Test
  97     public void getTableNameWhenNotUseRealItemNamesAndCount0() {
  98         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
  99         Mockito.doReturn(0).when(configurationMock).getTableIdDigitCount();
 100         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 101         assertThat(namingStrategy.getTableName(12345, "Test"), is("Item12345"));
 102     }
 103
 104     @Test
 105     public void prepareMigrationFromNumberedToRealNames() {
 106         final int itemId = 1;
 107         final String itemName = "Test";
 108         final String tableName = "Item1";
 109
 110         List<ItemVO> actual = prepareMigrationRealItemNames(itemId, itemName, tableName);
 111
 112         assertTableName(actual, "Test");
 113     }
 114
 115     @Test
 116     public void prepareMigrationWithChangedPrefix() {
 117         Mockito.doReturn(0).when(configurationMock).getTableIdDigitCount();
 118         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
 119
 120         final int itemId = 1;
 121         final String itemName = "Test";
 122         final String tableName = "Item1";
 123
 124         List<ItemVO> actual = prepareMigration(itemId, itemName, tableName, "item");
 125
 126         assertTableName(actual, "item1");
 127     }
 128
 129     @Test
 130     public void prepareMigrationShouldNotStopWhenEncounteringUnknownItem() {
 131         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 132         Mockito.doReturn(true).when(configurationMock).getTableCaseSensitiveItemNames();
 133         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 134
 135         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(2);
 136         itemIdToItemNameMap.put(1, "First");
 137         itemIdToItemNameMap.put(3, "Third");
 138
 139         List<String> itemTables = new ArrayList<String>(3);
 140         itemTables.add("Item1");
 141         itemTables.add("Item2");
 142         itemTables.add("Item3");
 143
 144         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 145
 146         assertThat(actual.size(), is(2));
 147         assertThat(actual.get(0).getNewTableName(), is("First"));
 148         assertThat(actual.get(1).getNewTableName(), is("Third"));
 149     }
 150
 151     @Test
 152     public void prepareMigrationFromMixedNumberedToNumberedRealNames() {
 153         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 154         Mockito.doReturn(false).when(configurationMock).getTableCaseSensitiveItemNames();
 155         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 156
 157         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(3);
 158         itemIdToItemNameMap.put(1, "First");
 159         itemIdToItemNameMap.put(2, "Second");
 160         itemIdToItemNameMap.put(3, "Third");
 161
 162         List<String> itemTables = new ArrayList<String>(3);
 163         itemTables.add("Item1");
 164         itemTables.add("Item002");
 165         itemTables.add("third_0003");
 166
 167         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 168
 169         assertThat(actual.size(), is(3));
 170         assertThat(actual.get(0).getNewTableName(), is("first_1"));
 171         assertThat(actual.get(1).getNewTableName(), is("second_2"));
 172         assertThat(actual.get(2).getNewTableName(), is("third_3"));
 173     }
 174
 175     @Test
 176     public void prepareMigrationFromMixedNumberedToCaseSensitiveRealNames() {
 177         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 178         Mockito.doReturn(true).when(configurationMock).getTableCaseSensitiveItemNames();
 179         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 180
 181         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(3);
 182         itemIdToItemNameMap.put(1, "First");
 183         itemIdToItemNameMap.put(2, "Second");
 184         itemIdToItemNameMap.put(3, "Third");
 185
 186         List<String> itemTables = new ArrayList<String>(3);
 187         itemTables.add("Item1");
 188         itemTables.add("Item002");
 189         itemTables.add("third_0003");
 190
 191         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 192
 193         assertThat(actual.size(), is(3));
 194         assertThat(actual.get(0).getNewTableName(), is("First"));
 195         assertThat(actual.get(1).getNewTableName(), is("Second"));
 196         assertThat(actual.get(2).getNewTableName(), is("Third"));
 197     }
 198
 199     @Test
 200     public void prepareMigrationFromNumberedRealNamesToCaseSensitiveRealNames() {
 201         final int itemId = 1;
 202         final String itemName = "Test";
 203         final String tableName = "test_0001";
 204
 205         List<ItemVO> actual = prepareMigrationRealItemNames(itemId, itemName, tableName, true);
 206
 207         assertTableName(actual, "Test");
 208     }
 209
 210     @Test
 211     public void prepareMigrationFromCaseSensitiveRealNamesToNumberedRealNames() {
 212         final int itemId = 1;
 213         final String itemName = "Test";
 214         final String tableName = "Test";
 215
 216         List<ItemVO> actual = prepareMigrationRealItemNames(itemId, itemName, tableName, false);
 217
 218         assertTableName(actual, "test_0001");
 219     }
 220
 221     @Test
 222     public void prepareMigrationRealNamesWithTwoItemsWithDifferentCaseToNumbered() {
 223         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
 224         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 225         Mockito.doReturn(1).when(configurationMock).getTableIdDigitCount();
 226
 227         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(2);
 228         itemIdToItemNameMap.put(1, "MyItem");
 229         itemIdToItemNameMap.put(2, "myItem");
 230
 231         List<String> itemTables = new ArrayList<String>(2);
 232         itemTables.add("MyItem");
 233         itemTables.add("myItem");
 234
 235         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 236
 237         assertThat(actual.size(), is(2));
 238         assertThat(actual.get(0).getNewTableName(), is("Item1"));
 239         assertThat(actual.get(1).getNewTableName(), is("Item2"));
 240     }
 241
 242     @Test
 243     public void prepareMigrationNumberedWithTwoItemsWithDifferentCaseToNumberedRealNames() {
 244         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 245         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 246         Mockito.doReturn(false).when(configurationMock).getTableCaseSensitiveItemNames();
 247
 248         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(2);
 249         itemIdToItemNameMap.put(1, "MyItem");
 250         itemIdToItemNameMap.put(2, "myItem");
 251
 252         List<String> itemTables = new ArrayList<String>(2);
 253         itemTables.add("Item1");
 254         itemTables.add("Item2");
 255
 256         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 257
 258         assertThat(actual.size(), is(2));
 259         assertThat(actual.get(0).getNewTableName(), is("myitem_1"));
 260         assertThat(actual.get(1).getNewTableName(), is("myitem_2"));
 261     }
 262
 263     @Test
 264     public void prepareMigrationNumberedWithTwoItemsWithDifferentCaseToCaseSensitiveRealNames() {
 265         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 266         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 267         Mockito.doReturn(true).when(configurationMock).getTableCaseSensitiveItemNames();
 268
 269         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(2);
 270         itemIdToItemNameMap.put(1, "MyItem");
 271         itemIdToItemNameMap.put(2, "myItem");
 272
 273         List<String> itemTables = new ArrayList<String>(2);
 274         itemTables.add("Item1");
 275         itemTables.add("Item2");
 276
 277         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 278
 279         assertThat(actual.size(), is(2));
 280         assertThat(actual.get(0).getNewTableName(), is("MyItem"));
 281         assertThat(actual.get(1).getNewTableName(), is("myItem"));
 282     }
 283
 284     @Test
 285     public void prepareMigrationFromNumberedRealNamesToCaseSensitiveRealNamesWhenUnknownItemIdThenSkip() {
 286         final int itemId = 2;
 287         final String itemName = "Test";
 288         final String tableName = "test_0001";
 289
 290         List<ItemVO> actual = prepareMigrationRealItemNames(itemId, itemName, tableName);
 291
 292         assertThat(actual.size(), is(0));
 293     }
 294
 295     @Test
 296     public void prepareMigrationFromNumberedRealNamesToNumbered() {
 297         final int itemId = 1;
 298         final String itemName = "Test";
 299         final String tableName = "test_0001";
 300
 301         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName);
 302
 303         assertTableName(actual, "Item0001");
 304     }
 305
 306     @Test
 307     public void prepareMigrationFromNumberedToNumberedWithCorrectPadding() {
 308         final int itemId = 1;
 309         final String itemName = "Test";
 310         final String tableName = "Item1";
 311
 312         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName, 2);
 313
 314         assertTableName(actual, "Item01");
 315     }
 316
 317     @Test
 318     public void prepareMigrationFromNumberedToNumberedExceedingPadding() {
 319         final int itemId = 101;
 320         final String itemName = "Test";
 321         final String tableName = "Item0101";
 322
 323         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName, 2);
 324
 325         assertTableName(actual, "Item101");
 326     }
 327
 328     @Test
 329     public void prepareMigrationFromCaseSensitiveRealNamesToNumbered() {
 330         final int itemId = 1;
 331         final String itemName = "Test";
 332         final String tableName = "Test";
 333
 334         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName);
 335
 336         assertTableName(actual, "Item0001");
 337     }
 338
 339     @Test
 340     public void prepareMigrationFromCaseSensitiveRealNamesToNumberedHavingUnderscore() {
 341         final int itemId = 1;
 342         final String itemName = "My_Test";
 343         final String tableName = "My_Test";
 344
 345         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName);
 346
 347         assertTableName(actual, "Item0001");
 348     }
 349
 350     @Test
 351     public void prepareMigrationFromCaseSensitiveRealNamesHavingUnderscoreAndNumberToNumbered() {
 352         final int itemId = 2;
 353         final String itemName = "My_Test_1";
 354         final String tableName = "My_Test_1";
 355
 356         List<ItemVO> actual = prepareMigrationNumbered(itemId, itemName, tableName);
 357
 358         assertTableName(actual, "Item0002");
 359     }
 360
 361     @Test
 362     public void prepareMigrationFromCaseSensitiveRealNamesToNumberedShouldSwap() {
 363         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
 364         Mockito.doReturn("Item").when(configurationMock).getTableNamePrefix();
 365
 366         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(2);
 367         itemIdToItemNameMap.put(1, "Item2");
 368         itemIdToItemNameMap.put(2, "Item1");
 369
 370         List<String> itemTables = new ArrayList<String>(2);
 371         itemTables.add("Item2");
 372         itemTables.add("Item1");
 373
 374         List<ItemVO> actual = namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 375
 376         assertThat(actual.size(), is(2));
 377         assertThat(actual.get(0).getNewTableName(), is("Item1"));
 378         assertThat(actual.get(1).getNewTableName(), is("Item2"));
 379     }
 380
 381     @Test
 382     public void prepareMigrationWhenConflictWithItemsManageTableThenSkip() {
 383         final int itemId = 1;
 384         final String itemName = "items";
 385         final String tableName = "Item1";
 386
 387         List<ItemVO> actual = prepareMigrationRealItemNames(itemId, itemName, tableName);
 388
 389         assertThat(actual.size(), is(0));
 390     }
 391
 392     private List<ItemVO> prepareMigrationNumbered(int itemId, String itemName, String tableName) {
 393         return prepareMigrationNumbered(itemId, itemName, tableName, 4);
 394     }
 395
 396     private List<ItemVO> prepareMigrationNumbered(int itemId, String itemName, String tableName,
 397             int tableIdDigitCount) {
 398         Mockito.doReturn(tableIdDigitCount).when(configurationMock).getTableIdDigitCount();
 399         Mockito.doReturn(false).when(configurationMock).getTableUseRealItemNames();
 400         return prepareMigration(itemId, itemName, tableName);
 401     }
 402
 403     private List<ItemVO> prepareMigrationRealItemNames(int itemId, String itemName, String tableName) {
 404         return prepareMigrationRealItemNames(itemId, itemName, tableName, true);
 405     }
 406
 407     private List<ItemVO> prepareMigrationRealItemNames(int itemId, String itemName, String tableName,
 408             boolean caseSensitive) {
 409         Mockito.doReturn(4).when(configurationMock).getTableIdDigitCount();
 410         Mockito.doReturn(true).when(configurationMock).getTableUseRealItemNames();
 411         Mockito.doReturn(caseSensitive).when(configurationMock).getTableCaseSensitiveItemNames();
 412         return prepareMigration(itemId, itemName, tableName);
 413     }
 414
 415     private List<ItemVO> prepareMigration(int itemId, String itemName, String tableName) {
 416         return prepareMigration(itemId, itemName, tableName, "Item");
 417     }
 418
 419     private List<ItemVO> prepareMigration(int itemId, String itemName, String tableName, String prefix) {
 420         Mockito.doReturn(prefix).when(configurationMock).getTableNamePrefix();
 421
 422         Map<Integer, String> itemIdToItemNameMap = getItemIdToItemNameMap(itemId, itemName);
 423         List<String> itemTables = getItemTables(tableName);
 424
 425         return namingStrategy.prepareMigration(itemTables, itemIdToItemNameMap, ITEMS_MANAGE_TABLE_NAME);
 426     }
 427
 428     private Map<Integer, String> getItemIdToItemNameMap(int itemId, String itemName) {
 429         Map<Integer, String> itemIdToItemNameMap = new HashMap<>(1);
 430         itemIdToItemNameMap.put(itemId, itemName);
 431         return itemIdToItemNameMap;
 432     }
 433
 434     private List<String> getItemTables(String tableName) {
 435         List<String> itemTables = new ArrayList<String>(1);
 436         itemTables.add(tableName);
 437         return itemTables;
 438     }
 439
 440     private void assertTableName(List<ItemVO> actual, String expected) {
 441         assertThat(actual.size(), is(1));
 442         assertThat(actual.get(0).getNewTableName(), is(expected));
 443     }
 444 }