flan/advanced-camera-card
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: Race condition in remote control entity handling (#2267)

Browse Source 
- Related #2244
This commit is contained in:
Dermot Duffy
2025-12-08 20:55:06 -08:00
committed by GitHub
parent a241e02594
commit f8138c2377
2 changed files with 361 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/card-controller/config/load-control-entities.test.ts
+318 -32
View File
@@ -1,6 +1,9 @@
import { assert, describe, expect, it, vi } from 'vitest';
import { describe, expect, it, vi } from 'vitest';
import { setRemoteControlEntityFromConfig } from '../../../src/card-controller/config/load-control-entities';
import { INTERNAL_CALLBACK_ACTION } from '../../../src/config/schema/actions/custom/internal';
import {
INTERNAL_CALLBACK_ACTION,
InternalCallbackActionConfig,
} from '../../../src/config/schema/actions/custom/internal';
import { isAdvancedCameraCardCustomAction } from '../../../src/utils/action';
import {
createCardAPI,
@@ -8,6 +11,7 @@ import {
createHASS,
createStateEntity,
createStore,
createView,
} from '../../test-utils';
describe('setRemoteControlEntityFromConfig', () => {
@@ -55,14 +59,9 @@ describe('setRemoteControlEntityFromConfig', () => {
{
actions: [
{
action: 'perform-action',
data: {
option: '{{ advanced_camera_card.trigger.camera.to }}',
},
perform_action: 'input_select.select_option',
target: {
entity_id: 'input_select.camera',
},
action: 'fire-dom-event',
advanced_camera_card_action: '__INTERNAL_CALLBACK_ACTION__',
callback: expect.any(Function),
},
],
conditions: [
@@ -75,14 +74,9 @@ describe('setRemoteControlEntityFromConfig', () => {
{
actions: [
{
action: 'perform-action',
data: {
option: '{{ advanced_camera_card.camera }}',
},
perform_action: 'input_select.select_option',
target: {
entity_id: 'input_select.camera',
},
action: 'fire-dom-event',
advanced_camera_card_action: '__INTERNAL_CALLBACK_ACTION__',
callback: expect.any(Function),
},
],
conditions: [
@@ -147,14 +141,9 @@ describe('setRemoteControlEntityFromConfig', () => {
{
actions: [
{
action: 'perform-action',
data: {
option: '{{ advanced_camera_card.trigger.camera.to }}',
},
perform_action: 'input_select.select_option',
target: {
entity_id: 'input_select.camera',
},
action: 'fire-dom-event',
advanced_camera_card_action: '__INTERNAL_CALLBACK_ACTION__',
callback: expect.any(Function),
},
],
conditions: [
@@ -225,9 +214,12 @@ describe('setRemoteControlEntityFromConfig', () => {
setRemoteControlEntityFromConfig(api);
const addOptionsAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][0].actions?.[0];
assert(addOptionsAction && isAdvancedCameraCardCustomAction(addOptionsAction));
assert(addOptionsAction.advanced_camera_card_action === INTERNAL_CALLBACK_ACTION);
.calls[0][0][0].actions?.[0] as InternalCallbackActionConfig;
expect(addOptionsAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(addOptionsAction)).toBeTruthy();
expect(addOptionsAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
addOptionsAction.callback(api);
expect(hass.callService).toBeCalledWith(
@@ -272,12 +264,306 @@ describe('setRemoteControlEntityFromConfig', () => {
setRemoteControlEntityFromConfig(api);
const addOptionsAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][0].actions?.[0];
assert(addOptionsAction && isAdvancedCameraCardCustomAction(addOptionsAction));
assert(addOptionsAction.advanced_camera_card_action === INTERNAL_CALLBACK_ACTION);
.calls[0][0][0].actions?.[0] as InternalCallbackActionConfig;
expect(addOptionsAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(addOptionsAction)).toBeTruthy();
expect(addOptionsAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
addOptionsAction.callback(api);
expect(hass.callService).not.toBeCalled();
});
it('should not throw when hass is undefined setting options', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(null);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
},
},
}),
);
const store = createStore([
{
cameraID: 'camera.one',
},
{
cameraID: 'camera.two',
},
]);
vi.mocked(api.getCameraManager().getStore).mockReturnValue(store);
setRemoteControlEntityFromConfig(api);
const addOptionsAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][0].actions?.[0] as InternalCallbackActionConfig;
expect(addOptionsAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(addOptionsAction)).toBeTruthy();
expect(addOptionsAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
// Should not throw
addOptionsAction.callback(api);
});
});
describe('should select option on entity', () => {
it('should select option when camera differs from entity state', () => {
const hass = createHASS({
'input_select.camera': createStateEntity({
state: 'camera.one',
}),
});
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(
createView({
camera: 'camera.two',
view: 'live',
}),
);
setRemoteControlEntityFromConfig(api);
// Get the camera sync callback (automation index 1)
const cameraSyncAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][1].actions?.[0] as InternalCallbackActionConfig;
expect(cameraSyncAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(cameraSyncAction)).toBeTruthy();
expect(cameraSyncAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
cameraSyncAction.callback(api);
expect(hass.callService).toBeCalledWith(
'input_select',
'select_option',
{
option: 'camera.two',
},
{
entity_id: 'input_select.camera',
},
);
});
it('should not select option when camera matches entity state', () => {
const hass = createHASS({
'input_select.camera': createStateEntity({
state: 'camera.one',
}),
});
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(
createView({
camera: 'camera.one',
view: 'live',
}),
);
setRemoteControlEntityFromConfig(api);
// Get the camera sync callback (automation index 1)
const cameraSyncAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][1].actions?.[0] as InternalCallbackActionConfig;
expect(cameraSyncAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(cameraSyncAction)).toBeTruthy();
expect(cameraSyncAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
cameraSyncAction.callback(api);
// Should NOT call select_option since entity already shows camera.one
expect(hass.callService).not.toBeCalled();
});
it('should not select option when camera is undefined', () => {
const hass = createHASS({
'input_select.camera': createStateEntity({
state: 'camera.one',
}),
});
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(null);
setRemoteControlEntityFromConfig(api);
// Get the camera sync callback (automation index 1)
const cameraSyncAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][1].actions?.[0] as InternalCallbackActionConfig;
expect(cameraSyncAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(cameraSyncAction)).toBeTruthy();
expect(cameraSyncAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
cameraSyncAction.callback(api);
// Should NOT call select_option since camera is undefined
expect(hass.callService).not.toBeCalled();
});
it('should not throw when hass is undefined', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(null);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(
createView({
camera: 'camera.two',
view: 'live',
}),
);
setRemoteControlEntityFromConfig(api);
const cameraSyncAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][1].actions?.[0] as InternalCallbackActionConfig;
expect(cameraSyncAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(cameraSyncAction)).toBeTruthy();
expect(cameraSyncAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
// Should not throw and obviously not call service (as hass is null)
cameraSyncAction.callback(api);
});
it('should select option when entity state is undefined', () => {
const hass = createHASS({});
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(
createView({
camera: 'camera.two',
view: 'live',
}),
);
setRemoteControlEntityFromConfig(api);
const cameraSyncAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][1].actions?.[0] as InternalCallbackActionConfig;
expect(cameraSyncAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(cameraSyncAction)).toBeTruthy();
expect(cameraSyncAction.advanced_camera_card_action).toBe(
INTERNAL_CALLBACK_ACTION,
);
cameraSyncAction.callback(api);
expect(hass.callService).toBeCalledWith(
'input_select',
'select_option',
{
option: 'camera.two',
},
{
entity_id: 'input_select.camera',
},
);
});
it('should select option on initialization with card priority', () => {
const hass = createHASS({
'input_select.camera': createStateEntity({
state: 'camera.one',
}),
});
const api = createCardAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
vi.mocked(api.getViewManager().getView).mockReturnValue(
createView({
camera: 'camera.two',
view: 'live',
}),
);
setRemoteControlEntityFromConfig(api);
// Get the initialization callback (automation index 2)
const initAction = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0][2].actions?.[0] as InternalCallbackActionConfig;
expect(initAction).toBeTruthy();
expect(isAdvancedCameraCardCustomAction(initAction)).toBeTruthy();
expect(initAction.advanced_camera_card_action).toBe(INTERNAL_CALLBACK_ACTION);
initAction.callback(api);
expect(hass.callService).toBeCalledWith(
'input_select',
'select_option',
{
option: 'camera.two',
},
{
entity_id: 'input_select.camera',
},
);
});
});
});