From 3e23fed3d616d1e3ea222f4555ea6f7f46fc1971 Mon Sep 17 00:00:00 2001 From: jamesread Date: Tue, 6 Jan 2026 21:38:18 +0000 Subject: [PATCH] feat: Enable/Disable actions based on rules --- .../tests/enabledExpression/config.yaml | 39 +++++ .../enabledExpression/enabledExpression.mjs | 88 ++++++++++ .../enabledExpression/entities/lights.yaml | 5 + service/internal/api/api_test.go | 162 ++++++++++++++++++ 4 files changed, 294 insertions(+) create mode 100644 integration-tests/tests/enabledExpression/config.yaml create mode 100644 integration-tests/tests/enabledExpression/enabledExpression.mjs create mode 100644 integration-tests/tests/enabledExpression/entities/lights.yaml diff --git a/integration-tests/tests/enabledExpression/config.yaml b/integration-tests/tests/enabledExpression/config.yaml new file mode 100644 index 0000000..66ea639 --- /dev/null +++ b/integration-tests/tests/enabledExpression/config.yaml @@ -0,0 +1,39 @@ +# +# Integration Test Config: EnabledExpression +# + +listenAddressSingleHTTPFrontend: 0.0.0.0:1337 + +logLevel: "DEBUG" +checkForUpdates: false + +actions: + - title: Turn On Light + shell: echo "Turning on light" + icon: light + entity: light + enabledExpression: "{{ eq .CurrentEntity.powered_on false }}" + + - title: Turn Off Light + shell: echo "Turning off light" + icon: light + entity: light + enabledExpression: "{{ eq .CurrentEntity.powered_on true }}" + + - title: Always Enabled Action + shell: echo "Always enabled" + icon: check + +entities: + - file: entities/lights.yaml + name: light + +dashboards: + - title: Lights Dashboard + contents: + - title: Light Controls + type: fieldset + entity: light + contents: + - title: Turn On Light + - title: Turn Off Light diff --git a/integration-tests/tests/enabledExpression/enabledExpression.mjs b/integration-tests/tests/enabledExpression/enabledExpression.mjs new file mode 100644 index 0000000..ce15b30 --- /dev/null +++ b/integration-tests/tests/enabledExpression/enabledExpression.mjs @@ -0,0 +1,88 @@ +import { describe, it, before, after } from 'mocha' +import { expect } from 'chai' +import { By, until } from 'selenium-webdriver' +import { + getRootAndWait, + takeScreenshotOnFailure, +} from '../../lib/elements.js' + +describe('config: enabledExpression', function () { + before(async function () { + await runner.start('enabledExpression') + }) + + after(async () => { + await runner.stop() + }) + + afterEach(function () { + takeScreenshotOnFailure(this.currentTest, webdriver); + }); + + it('Action with enabledExpression false is disabled', async function() { + await getRootAndWait() + + // Navigate to the Lights Dashboard + await webdriver.get(runner.baseUrl() + '/dashboard/Lights%20Dashboard') + + // Wait for dashboard to load + await webdriver.wait(until.elementLocated(By.css('.action-button')), 10000) + + // Find action buttons + const actionButtons = await webdriver.findElements(By.css('.action-button button')) + + // Find "Turn On Light" button for "Living Room Light" (powered_on: false, so Turn On should be enabled) + // Find "Turn Off Light" button for "Bedroom Light" (powered_on: true, so Turn Off should be enabled) + let turnOnButton = null + let turnOffButton = null + + for (const btn of actionButtons) { + const title = await btn.getAttribute('title') + if (title && title.includes('Turn On Light') && title.includes('Living Room')) { + turnOnButton = btn + } + if (title && title.includes('Turn Off Light') && title.includes('Bedroom')) { + turnOffButton = btn + } + } + + expect(turnOnButton).to.not.be.null + expect(turnOffButton).to.not.be.null + + // Check that Turn On button is enabled (light is off) + const turnOnDisabled = await turnOnButton.getAttribute('disabled') + expect(turnOnDisabled).to.be.null + + // Check that Turn Off button is enabled (light is on) + const turnOffDisabled = await turnOffButton.getAttribute('disabled') + expect(turnOffDisabled).to.be.null + }) + + it('Action without enabledExpression is always enabled', async function() { + await getRootAndWait() + + // Navigate to actions view + await webdriver.get(runner.baseUrl()) + + // Wait for action buttons + await webdriver.wait(until.elementLocated(By.css('.action-button')), 10000) + + // Find "Always Enabled Action" button + const actionButtons = await webdriver.findElements(By.css('.action-button button')) + let alwaysEnabledButton = null + + for (const btn of actionButtons) { + const title = await btn.getAttribute('title') + if (title === 'Always Enabled Action') { + alwaysEnabledButton = btn + break + } + } + + expect(alwaysEnabledButton).to.not.be.null + + // Check that it's enabled + const disabled = await alwaysEnabledButton.getAttribute('disabled') + expect(disabled).to.be.null + }) +}) diff --git a/integration-tests/tests/enabledExpression/entities/lights.yaml b/integration-tests/tests/enabledExpression/entities/lights.yaml new file mode 100644 index 0000000..628fcc1 --- /dev/null +++ b/integration-tests/tests/enabledExpression/entities/lights.yaml @@ -0,0 +1,5 @@ +- name: "Living Room Light" + powered_on: false + +- name: "Bedroom Light" + powered_on: true diff --git a/service/internal/api/api_test.go b/service/internal/api/api_test.go index 68341ae..9d20559 100644 --- a/service/internal/api/api_test.go +++ b/service/internal/api/api_test.go @@ -11,6 +11,7 @@ import ( apiv1 "github.com/OliveTin/OliveTin/gen/olivetin/api/v1" apiv1connect "github.com/OliveTin/OliveTin/gen/olivetin/api/v1/apiv1connect" + authpublic "github.com/OliveTin/OliveTin/internal/auth/authpublic" config "github.com/OliveTin/OliveTin/internal/config" "github.com/OliveTin/OliveTin/internal/entities" "github.com/OliveTin/OliveTin/internal/executor" @@ -173,3 +174,164 @@ func validateConsistency(t *testing.T, client apiv1connect.OliveTinApiServiceCli } } } + +func TestEvaluateEnabledExpression(t *testing.T) { + tests := []struct { + name string + expression string + entity *entities.Entity + expectedResult bool + }{ + { + name: "empty expression returns true", + expression: "", + entity: nil, + expectedResult: true, + }, + { + name: "literal true returns true", + expression: "true", + entity: nil, + expectedResult: true, + }, + { + name: "literal True returns true (case insensitive)", + expression: "True", + entity: nil, + expectedResult: true, + }, + { + name: "literal 1 returns true", + expression: "1", + entity: nil, + expectedResult: true, + }, + { + name: "literal false returns false", + expression: "false", + entity: nil, + expectedResult: false, + }, + { + name: "literal 0 returns false", + expression: "0", + entity: nil, + expectedResult: false, + }, + { + name: "empty result returns false", + expression: "{{ .NonExistent }}", + entity: nil, + expectedResult: false, + }, + { + name: "expression with CurrentEntity true", + expression: "{{ eq .CurrentEntity.powered_on true }}", + entity: &entities.Entity{Data: map[string]any{"powered_on": true}}, + expectedResult: true, + }, + { + name: "expression with CurrentEntity false", + expression: "{{ eq .CurrentEntity.powered_on true }}", + entity: &entities.Entity{Data: map[string]any{"powered_on": false}}, + expectedResult: false, + }, + { + name: "expression with CurrentEntity integer 1", + expression: "{{ .CurrentEntity.status }}", + entity: &entities.Entity{Data: map[string]any{"status": 1}}, + expectedResult: true, + }, + { + name: "expression with CurrentEntity integer 0", + expression: "{{ .CurrentEntity.status }}", + entity: &entities.Entity{Data: map[string]any{"status": 0}}, + expectedResult: false, + }, + { + name: "template parse error returns false", + expression: "{{ invalid syntax }}", + entity: nil, + expectedResult: false, + }, + { + name: "template exec error returns false", + expression: "{{ .CurrentEntity.nonexistent }}", + entity: nil, + expectedResult: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + action := &config.Action{ + EnabledExpression: tt.expression, + } + result := evaluateEnabledExpression(action, tt.entity) + assert.Equal(t, tt.expectedResult, result, "evaluateEnabledExpression should return expected result") + }) + } +} + +func TestBuildActionWithEnabledExpression(t *testing.T) { + cfg := config.DefaultConfig() + cfg.DefaultPermissions.Exec = true + + action := &config.Action{ + Title: "Test Action", + Shell: "echo test", + EnabledExpression: "{{ eq .CurrentEntity.enabled true }}", + } + cfg.Actions = append(cfg.Actions, action) + + ex := executor.DefaultExecutor(cfg) + ex.RebuildActionMap() + + binding := findBindingByTitle(ex, "Test Action") + assert.NotNil(t, binding, "Binding should be found") + + rr := &DashboardRenderRequest{ + AuthenticatedUser: &authpublic.AuthenticatedUser{Username: "testuser"}, + cfg: cfg, + ex: ex, + } + + testWithEntity(t, binding, rr, true, true, "Action should be executable when entity.enabled is true") + testWithEntity(t, binding, rr, false, false, "Action should not be executable when entity.enabled is false") + + bindingNoExpr := findBindingByTitle(ex, "Test Action No Expression") + if bindingNoExpr == nil { + actionNoExpression := &config.Action{ + Title: "Test Action No Expression", + Shell: "echo test", + } + cfg.Actions = append(cfg.Actions, actionNoExpression) + ex.RebuildActionMap() + bindingNoExpr = findBindingByTitle(ex, "Test Action No Expression") + } + + actionResult := buildAction(bindingNoExpr, rr) + assert.True(t, actionResult.CanExec, "Action without enabledExpression should be executable") +} + +func findBindingByTitle(ex *executor.Executor, title string) *executor.ActionBinding { + ex.MapActionIdToBindingLock.RLock() + defer ex.MapActionIdToBindingLock.RUnlock() + + for _, b := range ex.MapActionIdToBinding { + if b.Action.Title == title { + return b + } + } + return nil +} + +func testWithEntity(t *testing.T, binding *executor.ActionBinding, rr *DashboardRenderRequest, enabled bool, expectedCanExec bool, message string) { + binding.Entity = &entities.Entity{ + UniqueKey: "test-entity", + Data: map[string]any{"enabled": enabled}, + } + + actionResult := buildAction(binding, rr) + assert.Equal(t, expectedCanExec, actionResult.CanExec, message) +}