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

   1 /**
   2  * Copyright (c) 2010-2022 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.binding.hdpowerview;
  14
  15 import static org.junit.jupiter.api.Assertions.assertEquals;
  16 import static org.mockito.Mockito.mock;
  17
  18 import java.util.ArrayList;
  19 import java.util.Base64;
  20 import java.util.List;
  21
  22 import org.eclipse.jdt.annotation.NonNullByDefault;
  23 import org.junit.jupiter.api.BeforeEach;
  24 import org.junit.jupiter.api.Test;
  25 import org.openhab.binding.hdpowerview.internal.HDPowerViewBindingConstants;
  26 import org.openhab.binding.hdpowerview.internal.HDPowerViewTranslationProvider;
  27 import org.openhab.binding.hdpowerview.internal.api.responses.SceneCollections.SceneCollection;
  28 import org.openhab.binding.hdpowerview.internal.api.responses.Scenes.Scene;
  29 import org.openhab.binding.hdpowerview.internal.api.responses.ScheduledEvents;
  30 import org.openhab.binding.hdpowerview.internal.api.responses.ScheduledEvents.ScheduledEvent;
  31 import org.openhab.binding.hdpowerview.internal.builders.AutomationChannelBuilder;
  32 import org.openhab.binding.hdpowerview.providers.MockedLocaleProvider;
  33 import org.openhab.binding.hdpowerview.providers.MockedTranslationProvider;
  34 import org.openhab.core.thing.Channel;
  35 import org.openhab.core.thing.ChannelGroupUID;
  36 import org.openhab.core.thing.ThingUID;
  37 import org.osgi.framework.Bundle;
  38 import org.slf4j.LoggerFactory;
  39
  40 import ch.qos.logback.classic.Level;
  41 import ch.qos.logback.classic.Logger;
  42
  43 /**
  44  * Unit tests for {@link AutomationChannelBuilder}.
  45  *
  46  * @author Jacob Laursen - Initial contribution
  47  */
  48 @NonNullByDefault
  49 public class AutomationChannelBuilderTest {
  50
  51     private static final ChannelGroupUID CHANNEL_GROUP_UID = new ChannelGroupUID(
  52             new ThingUID(HDPowerViewBindingConstants.BINDING_ID, AutomationChannelBuilderTest.class.getSimpleName()),
  53             HDPowerViewBindingConstants.CHANNELTYPE_AUTOMATION_ENABLED);
  54
  55     private static final HDPowerViewTranslationProvider TRANSLATION_PROVIDER = new HDPowerViewTranslationProvider(
  56             mock(Bundle.class), new MockedTranslationProvider(), new MockedLocaleProvider());
  57
  58     private AutomationChannelBuilder builder = AutomationChannelBuilder.create(TRANSLATION_PROVIDER, CHANNEL_GROUP_UID);
  59     private List<Scene> scenes = new ArrayList<>();
  60     private List<SceneCollection> sceneCollections = new ArrayList<>();
  61
  62     @BeforeEach
  63     private void setUp() {
  64         final Logger logger = (Logger) LoggerFactory.getLogger(AutomationChannelBuilder.class);
  65         logger.setLevel(Level.OFF);
  66         builder = AutomationChannelBuilder.create(TRANSLATION_PROVIDER, CHANNEL_GROUP_UID);
  67
  68         Scene scene = new Scene();
  69         scene.id = 1;
  70         scene.name = Base64.getEncoder().encodeToString(("TestScene").getBytes());
  71         scenes = new ArrayList<>(List.of(scene));
  72
  73         SceneCollection sceneCollection = new SceneCollection();
  74         sceneCollection.id = 2;
  75         sceneCollection.name = Base64.getEncoder().encodeToString(("TestSceneCollection").getBytes());
  76         sceneCollections = new ArrayList<>(List.of(sceneCollection));
  77     }
  78
  79     @Test
  80     public void sceneSunriseWeekends() {
  81         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
  82         scheduledEvent.daySaturday = true;
  83         scheduledEvent.daySunday = true;
  84
  85         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
  86         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
  87
  88         assertEquals(1, channels.size());
  89         assertEquals("TestScene, At sunrise, Weekends", channels.get(0).getLabel());
  90     }
  91
  92     @Test
  93     public void sceneSunsetWeekdays() {
  94         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNSET);
  95         scheduledEvent.dayMonday = true;
  96         scheduledEvent.dayTuesday = true;
  97         scheduledEvent.dayWednesday = true;
  98         scheduledEvent.dayThursday = true;
  99         scheduledEvent.dayFriday = true;
 100
 101         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 102         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 103
 104         assertEquals(1, channels.size());
 105         assertEquals("TestScene, At sunset, Weekdays", channels.get(0).getLabel());
 106     }
 107
 108     @Test
 109     public void sceneTimeAllDays() {
 110         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_TIME);
 111         scheduledEvent.dayMonday = true;
 112         scheduledEvent.dayTuesday = true;
 113         scheduledEvent.dayWednesday = true;
 114         scheduledEvent.dayThursday = true;
 115         scheduledEvent.dayFriday = true;
 116         scheduledEvent.daySaturday = true;
 117         scheduledEvent.daySunday = true;
 118         scheduledEvent.hour = 6;
 119         scheduledEvent.minute = 30;
 120
 121         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 122         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 123
 124         assertEquals(1, channels.size());
 125         assertEquals("TestScene, 06:30, All days", channels.get(0).getLabel());
 126     }
 127
 128     @Test
 129     public void sceneMinutesBeforeSunriseMondayTuesday() {
 130         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 131         scheduledEvent.dayMonday = true;
 132         scheduledEvent.dayTuesday = true;
 133         scheduledEvent.minute = -15;
 134
 135         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 136         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 137
 138         assertEquals(1, channels.size());
 139         assertEquals("TestScene, 15m before sunrise, Mon, Tue", channels.get(0).getLabel());
 140     }
 141
 142     @Test
 143     public void sceneHoursMinutesAfterSunriseMonday() {
 144         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 145         scheduledEvent.dayMonday = true;
 146         scheduledEvent.minute = 61;
 147
 148         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 149         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 150
 151         assertEquals(1, channels.size());
 152         assertEquals("TestScene, 1hr 1m after sunrise, Mon", channels.get(0).getLabel());
 153     }
 154
 155     @Test
 156     public void sceneMinutesBeforeSunsetWednesdayThursdayFriday() {
 157         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNSET);
 158         scheduledEvent.dayWednesday = true;
 159         scheduledEvent.dayThursday = true;
 160         scheduledEvent.dayFriday = true;
 161         scheduledEvent.minute = -59;
 162
 163         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 164         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 165
 166         assertEquals(1, channels.size());
 167         assertEquals("TestScene, 59m before sunset, Wed, Thu, Fri", channels.get(0).getLabel());
 168     }
 169
 170     @Test
 171     public void sceneHourAfterSunsetFridaySaturdaySunday() {
 172         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNSET);
 173         scheduledEvent.dayFriday = true;
 174         scheduledEvent.daySaturday = true;
 175         scheduledEvent.daySunday = true;
 176         scheduledEvent.minute = 60;
 177
 178         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 179         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 180
 181         assertEquals(1, channels.size());
 182         assertEquals("TestScene, 1hr after sunset, Fri, Sat, Sun", channels.get(0).getLabel());
 183     }
 184
 185     @Test
 186     public void sceneCollection() {
 187         ScheduledEvent scheduledEvent = createScheduledEventWithSceneCollection(
 188                 ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 189
 190         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 191         List<Channel> channels = builder.withSceneCollections(sceneCollections).withScheduledEvents(scheduledEvents)
 192                 .build();
 193
 194         assertEquals(1, channels.size());
 195         assertEquals("TestSceneCollection, At sunrise, ", channels.get(0).getLabel());
 196     }
 197
 198     @Test
 199     public void suppliedListIsUsed() {
 200         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 201         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 202         List<Channel> existingChannels = new ArrayList<>(0);
 203         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents)
 204                 .withChannels(existingChannels).build();
 205
 206         assertEquals(existingChannels, channels);
 207     }
 208
 209     @Test
 210     public void emptyListWhenNoScheduledEvents() {
 211         List<Channel> channels = builder.build();
 212
 213         assertEquals(0, channels.size());
 214     }
 215
 216     @Test
 217     public void emptyListWhenNoScenesOrSceneCollections() {
 218         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 219         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 220         List<Channel> channels = builder.withScheduledEvents(scheduledEvents).build();
 221
 222         assertEquals(0, channels.size());
 223     }
 224
 225     @Test
 226     public void emptyListWhenNoSceneForScheduledEvent() {
 227         ScheduledEvent scheduledEvent = createScheduledEventWithSceneCollection(
 228                 ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 229         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 230         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 231
 232         assertEquals(0, channels.size());
 233     }
 234
 235     @Test
 236     public void emptyListWhenNoSceneCollectionForScheduledEvent() {
 237         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 238         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 239
 240         List<Channel> channels = builder.withSceneCollections(sceneCollections).withScheduledEvents(scheduledEvents)
 241                 .build();
 242
 243         assertEquals(0, channels.size());
 244     }
 245
 246     @Test
 247     public void groupAndIdAreCorrect() {
 248         ScheduledEvent scheduledEvent = createScheduledEventWithScene(ScheduledEvents.SCHEDULED_EVENT_TYPE_SUNRISE);
 249         scheduledEvent.id = 42;
 250         List<ScheduledEvent> scheduledEvents = new ArrayList<>(List.of(scheduledEvent));
 251         List<Channel> channels = builder.withScenes(scenes).withScheduledEvents(scheduledEvents).build();
 252
 253         assertEquals(1, channels.size());
 254         assertEquals(CHANNEL_GROUP_UID.getId(), channels.get(0).getUID().getGroupId());
 255         assertEquals(Integer.toString(scheduledEvent.id), channels.get(0).getUID().getIdWithoutGroup());
 256     }
 257
 258     private ScheduledEvent createScheduledEventWithScene(int eventType) {
 259         ScheduledEvent scheduledEvent = new ScheduledEvent();
 260         scheduledEvent.id = 1;
 261         scheduledEvent.sceneId = scenes.get(0).id;
 262         scheduledEvent.eventType = eventType;
 263         return scheduledEvent;
 264     }
 265
 266     private ScheduledEvent createScheduledEventWithSceneCollection(int eventType) {
 267         ScheduledEvent scheduledEvent = new ScheduledEvent();
 268         scheduledEvent.id = 1;
 269         scheduledEvent.sceneCollectionId = sceneCollections.get(0).id;
 270         scheduledEvent.eventType = eventType;
 271         return scheduledEvent;
 272     }
 273 }