Examples with Action org.openhab.core.automation.Action used on opensource projects

Example 21 with Action

use of org.openhab.core.automation.Action in project openhab-core by openhab.

the class RuleEventTest method testRuleEvents.

@Test
public void testRuleEvents() throws ItemNotFoundException {
    // Registering eventSubscriber
    List<Event> ruleEvents = new ArrayList<>();
    EventSubscriber ruleEventHandler = new EventSubscriber() {

        @Override
        public Set<String> getSubscribedEventTypes() {
            return Set.of(RuleAddedEvent.TYPE, RuleRemovedEvent.TYPE, RuleStatusInfoEvent.TYPE, RuleUpdatedEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }

        @Override
        public void receive(Event event) {
            logger.info("RuleEvent: {}", event.getTopic());
            ruleEvents.add(event);
        }
    };
    registerService(ruleEventHandler);
    // Creation of RULE
    Configuration triggerConfig = new Configuration(Map.ofEntries(entry("eventSource", "myMotionItem2"), entry("eventTopic", "openhab/*"), entry("eventTypes", "ItemStateEvent")));
    Configuration actionConfig = new Configuration(Map.ofEntries(entry("itemName", "myLampItem2"), entry("command", "ON")));
    List<Trigger> triggers = List.of(ModuleBuilder.createTrigger().withId("ItemStateChangeTrigger2").withTypeUID("core.GenericEventTrigger").withConfiguration(triggerConfig).build());
    List<Action> actions = List.of(ModuleBuilder.createAction().withId("ItemPostCommandAction2").withTypeUID("core.ItemCommandAction").withConfiguration(actionConfig).build());
    Rule rule = RuleBuilder.create("myRule21").withTriggers(triggers).withActions(actions).withName("RuleEventTestingRule").build();
    logger.info("Rule created: {}", rule.getUID());
    RuleRegistry ruleRegistry = getService(RuleRegistry.class);
    RuleManager ruleEngine = getService(RuleManager.class);
    ruleRegistry.add(rule);
    ruleEngine.setEnabled(rule.getUID(), true);
    waitForAssert(() -> {
        assertThat(ruleEngine.getStatusInfo(rule.getUID()).getStatus(), is(RuleStatus.IDLE));
    });
    // TEST RULE
    EventPublisher eventPublisher = getService(EventPublisher.class);
    ItemRegistry itemRegistry = getService(ItemRegistry.class);
    SwitchItem myMotionItem = (SwitchItem) itemRegistry.getItem("myMotionItem2");
    assertNotNull(myMotionItem);
    eventPublisher.post(ItemEventFactory.createStateEvent("myPresenceItem2", OnOffType.ON));
    EventSubscriber itemEventHandler = new EventSubscriber() {

        @Override
        public void receive(Event event) {
            logger.info("Event: {}", event.getTopic());
            if (event instanceof ItemCommandEvent && event.getTopic().contains("myLampItem2")) {
                itemEvent = event;
            }
        }

        @Override
        public Set<String> getSubscribedEventTypes() {
            return Set.of(ItemCommandEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }
    };
    registerService(itemEventHandler);
    eventPublisher.post(ItemEventFactory.createStateEvent("myMotionItem2", OnOffType.ON));
    waitForAssert(() -> assertThat(itemEvent, is(notNullValue())));
    assertThat(itemEvent.getTopic(), is(equalTo("openhab/items/myLampItem2/command")));
    assertThat(((ItemCommandEvent) itemEvent).getItemCommand(), is(OnOffType.ON));
    assertThat(ruleEvents.size(), is(not(0)));
    assertThat(ruleEvents.stream().filter(e -> "openhab/rules/myRule21/added".equals(e.getTopic())).findFirst().isPresent(), is(true));
    assertThat(ruleEvents.stream().filter(e -> "openhab/rules/myRule21/state".equals(e.getTopic())).findFirst().isPresent(), is(true));
    List<Event> stateEvents = ruleEvents.stream().filter(e -> "openhab/rules/myRule21/state".equals(e.getTopic())).collect(Collectors.toList());
    assertThat(stateEvents, is(notNullValue()));
    Optional<Event> runningEvent = stateEvents.stream().filter(e -> ((RuleStatusInfoEvent) e).getStatusInfo().getStatus() == RuleStatus.RUNNING).findFirst();
    assertThat(runningEvent.isPresent(), is(true));
    EventSubscriber ruleRemovedEventHandler = new EventSubscriber() {

        @Override
        public Set<String> getSubscribedEventTypes() {
            return Set.of(RuleRemovedEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }

        @Override
        public void receive(Event event) {
            logger.info("RuleRemovedEvent: {}", event.getTopic());
            ruleRemovedEvent = event;
        }
    };
    registerService(ruleRemovedEventHandler);
    ruleRegistry.remove("myRule21");
    waitForAssert(() -> {
        assertThat(ruleRemovedEvent, is(notNullValue()));
        assertThat(ruleRemovedEvent.getTopic(), is(equalTo("openhab/rules/myRule21/removed")));
    });
}

Example 22 with Action

use of org.openhab.core.automation.Action in project openhab-core by openhab.

the class AutomationIntegrationJsonTest method assertThatARuleFromJsonFileIsAddedAutomatically.

@Test
public void assertThatARuleFromJsonFileIsAddedAutomatically() {
    logger.info("assert that a rule from json file is added automatically");
    // WAIT until Rule modules types are parsed and the rule becomes IDLE
    waitForAssert(() -> {
        assertThat(ruleRegistry.getAll().isEmpty(), is(false));
        Optional<Rule> rule2 = ruleRegistry.stream().filter(RulePredicates.hasAnyOfTags("jsonTest").and(RulePredicates.hasAnyOfTags("references").negate())).findFirst();
        assertThat(rule2.isPresent(), is(true));
        RuleStatusInfo ruleStatus2 = ruleManager.getStatusInfo(rule2.get().getUID());
        assertThat(ruleStatus2.getStatus(), is(RuleStatus.IDLE));
    }, 10000, 200);
    Optional<Rule> optionalRule = ruleRegistry.stream().filter(RulePredicates.hasAnyOfTags("jsonTest").and(RulePredicates.hasAnyOfTags("references").negate())).findFirst();
    assertThat(optionalRule.isPresent(), is(true));
    Rule rule = optionalRule.get();
    assertThat(rule.getName(), is("ItemSampleRule"));
    assertTrue(rule.getTags().contains("sample"));
    assertTrue(rule.getTags().contains("item"));
    assertTrue(rule.getTags().contains("rule"));
    Optional<? extends Trigger> trigger = rule.getTriggers().stream().filter(t -> "ItemStateChangeTriggerID".equals(t.getId())).findFirst();
    assertThat(trigger.isPresent(), is(true));
    assertThat(trigger.get().getTypeUID(), is("core.GenericEventTrigger"));
    assertThat(trigger.get().getConfiguration().get("eventSource"), is("myMotionItem"));
    assertThat(trigger.get().getConfiguration().get("eventTopic"), is("openhab/items/*"));
    assertThat(trigger.get().getConfiguration().get("eventTypes"), is("ItemStateEvent"));
    Optional<? extends Action> action = rule.getActions().stream().filter(a -> "ItemPostCommandActionID".equals(a.getId())).findFirst();
    assertThat(action.isPresent(), is(true));
    assertThat(action.get().getTypeUID(), is("core.ItemCommandAction"));
    assertThat(action.get().getConfiguration().get("itemName"), is("myLampItem"));
    assertThat(action.get().getConfiguration().get("command"), is("ON"));
    RuleStatusInfo ruleStatus = ruleManager.getStatusInfo(rule.getUID());
    assertThat(ruleStatus.getStatus(), is(RuleStatus.IDLE));
}

Example 23 with Action

use of org.openhab.core.automation.Action in project openhab-core by openhab.

the class BasicConditionHandlerTest method assertThatConditionWorksInRule.

@Test
public void assertThatConditionWorksInRule() throws ItemNotFoundException {
    String testItemName1 = "TriggeredItem";
    String testItemName2 = "SwitchedItem";
    /*
         * Create Rule
         */
    logger.info("Create rule");
    Configuration triggerConfig = new Configuration(Map.of("itemName", testItemName1));
    List<Trigger> triggers = List.of(ModuleBuilder.createTrigger().withId("MyTrigger").withTypeUID(ItemStateTriggerHandler.UPDATE_MODULE_TYPE_ID).withConfiguration(triggerConfig).build());
    List<Condition> conditions = List.of(getPassingCondition());
    Map<String, Object> cfgEntries = new HashMap<>();
    cfgEntries.put("itemName", testItemName2);
    cfgEntries.put("command", "ON");
    Configuration actionConfig = new Configuration(cfgEntries);
    List<Action> actions = List.of(ModuleBuilder.createAction().withId("MyItemPostCommandAction").withTypeUID(ItemCommandActionHandler.ITEM_COMMAND_ACTION).withConfiguration(actionConfig).build());
    // prepare the execution
    EventPublisher eventPublisher = getService(EventPublisher.class);
    // start rule engine
    RuleEngineImpl ruleEngine = requireNonNull((RuleEngineImpl) getService(RuleManager.class));
    ruleEngine.onReadyMarkerAdded(new ReadyMarker("", ""));
    waitForAssert(() -> assertTrue(ruleEngine.isStarted()));
    EventSubscriber itemEventHandler = new EventSubscriber() {

        @Override
        public Set<String> getSubscribedEventTypes() {
            return Set.of(ItemCommandEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }

        @Override
        public void receive(Event event) {
            logger.info("Event: {}", event.getTopic());
            if (event.getTopic().contains(testItemName2)) {
                BasicConditionHandlerTest.this.itemEvent = event;
            }
        }
    };
    registerService(itemEventHandler);
    Rule rule = RuleBuilder.create("MyRule" + new Random().nextInt()).withTriggers(triggers).withConditions(conditions).withActions(actions).withName("MyConditionTestRule").build();
    logger.info("Rule created: {}", rule.getUID());
    logger.info("Add rule");
    ruleRegistry.add(rule);
    logger.info("Rule added");
    logger.info("Enable rule and wait for idle status");
    ruleEngine.setEnabled(rule.getUID(), true);
    waitForAssert(() -> {
        final RuleStatusInfo ruleStatus = ruleEngine.getStatusInfo(rule.getUID());
        assertThat(ruleStatus.getStatus(), is(RuleStatus.IDLE));
    });
    logger.info("Rule is enabled and idle");
    logger.info("Send and wait for item state is ON");
    eventPublisher.post(ItemEventFactory.createStateEvent(testItemName1, OnOffType.ON));
    waitForAssert(() -> {
        assertThat(itemEvent, is(notNullValue()));
        assertThat(((ItemCommandEvent) itemEvent).getItemCommand(), is(OnOffType.ON));
    });
    logger.info("item state is ON");
    // now make the condition fail
    Rule rule2 = RuleBuilder.create(rule).withConditions(ModuleBuilder.createCondition(rule.getConditions().get(0)).withConfiguration(getFailingConfiguration()).build()).build();
    ruleRegistry.update(rule2);
    // prepare the execution
    itemEvent = null;
    eventPublisher.post(ItemEventFactory.createStateEvent(testItemName1, OnOffType.ON));
    waitForAssert(() -> {
        assertThat(itemEvent, is(nullValue()));
    });
}

Example 24 with Action

use of org.openhab.core.automation.Action in project openhab-core by openhab.

the class RuntimeRuleTest method assertThatTimerTriggerWorks.

@Test
public void assertThatTimerTriggerWorks() {
    String testItemName = "myLampItem";
    List<Event> itemEvents = new LinkedList<>();
    EventSubscriber itemEventHandler = new EventSubscriber() {

        @Override
        public void receive(Event event) {
            if (event.getTopic().contains(testItemName)) {
                itemEvents.add(event);
            }
        }

        @Override
        public java.util.Set<String> getSubscribedEventTypes() {
            return Set.of(ItemCommandEvent.TYPE);
        }

        @Override
        @Nullable
        public EventFilter getEventFilter() {
            return null;
        }
    };
    registerService(itemEventHandler);
    /*
         * Create Rule
         */
    logger.info("Create rule");
    String testExpression = "* * * * * ?";
    Configuration triggerConfig = new Configuration(Map.of("cronExpression", testExpression));
    List<Trigger> triggers = List.of(ModuleBuilder.createTrigger().withId("MyTimerTrigger").withTypeUID(GenericCronTriggerHandler.MODULE_TYPE_ID).withConfiguration(triggerConfig).build());
    Map<String, Object> cfgEntries = new HashMap<>();
    cfgEntries.put("itemName", testItemName);
    cfgEntries.put("command", "ON");
    Configuration actionConfig = new Configuration(cfgEntries);
    List<Action> actions = List.of(ModuleBuilder.createAction().withId("MyItemPostCommandAction").withTypeUID("core.ItemCommandAction").withConfiguration(actionConfig).build());
    Rule rule = RuleBuilder.create("MyRule" + new Random().nextInt()).withTriggers(triggers).withActions(actions).withName("MyTimerTriggerTestRule").build();
    logger.info("Rule created: {}", rule.getUID());
    logger.info("Add rule");
    ruleRegistry.add(rule);
    logger.info("Rule added");
    logger.info("Enable rule and wait for idle status");
    ruleEngine.setEnabled(rule.getUID(), true);
    waitForAssert(() -> {
        final RuleStatusInfo ruleStatus = ruleEngine.getStatusInfo(rule.getUID());
        assertThat(ruleStatus.getStatus(), is(RuleStatus.IDLE));
    });
    logger.info("Rule is enabled and idle");
    waitForAssert(() -> {
        assertThat(itemEvents.size(), is(3));
    });
}

Example 25 with Action

use of org.openhab.core.automation.Action in project openhab-core by openhab.

the class RuleEngineTest method createActions.

private List<Action> createActions(String type) {
    List<Action> actions = new ArrayList<>();
    Configuration configurations = new Configuration();
    configurations.put("a", "x");
    configurations.put("b", "y");
    configurations.put("c", "z");
    Map<String, String> inputs = new HashMap<>(11);
    String ouputModuleId = "triggerId";
    String outputName = "triggerOutput";
    String inputName = "actionInput";
    inputs.put(inputName, ouputModuleId + "." + outputName);
    inputs.put("in6", ouputModuleId + "." + outputName);
    actions.add(ModuleBuilder.createAction().withId("actionId").withTypeUID(type).withConfiguration(configurations).withInputs(inputs).build());
    return actions;
}