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