> **Note**: OCPP 2.0.x implementation is **partial** and under active development.
-#### Provisioning
+#### A. Provisioning
- :white_check_mark: BootNotification
-- :white_check_mark: GetBaseReport (partial)
-- :white_check_mark: GetVariables
+- :white_check_mark: GetBaseReport
- :white_check_mark: NotifyReport
-#### Authorization
+#### B. Authorization
- :white_check_mark: ClearCache
-#### Availability
+#### C. Availability
-- :white_check_mark: StatusNotification
- :white_check_mark: Heartbeat
+- :white_check_mark: StatusNotification
+
+#### E. Transactions
+
+- :x: RequestStartTransaction
+- :x: RequestStopTransaction
+- :x: TransactionEvent
+
+#### F. RemoteControl
+
+- :white_check_mark: Reset
+
+#### G. Monitoring
+
+- :white_check_mark: GetVariables
+- :x: SetVariables
+
+#### H. FirmwareManagement
+
+- :x: UpdateFirmware
+- :x: FirmwareStatusNotification
+
+#### I. ISO15118CertificateManagement
+
+- :x: InstallCertificate
+- :x: DeleteCertificate
+
+#### J. LocalAuthorizationListManagement
+
+- :x: GetLocalListVersion
+- :x: SendLocalList
+
+#### K. DataTransfer
+
+- :x: DataTransfer
## OCPP-J standard parameters supported
### Version 2.0.x
-> **Note**: OCPP 2.0.x variables management is not implemented yet.
+> **Note**: OCPP 2.0.x variables management is not yet implemented.
## UI Protocol
type OCPP20NotifyReportRequest,
type OCPP20NotifyReportResponse,
OCPP20RequestCommand,
+ type OCPP20ResetRequest,
+ type OCPP20ResetResponse,
OCPPVersion,
+ ReasonCodeEnumType,
ReportBaseEnumType,
type ReportDataType,
+ ResetEnumType,
+ ResetStatusEnumType,
+ StopTransactionReason,
} from '../../../types/index.js'
import { isAsyncFunction, logger } from '../../../utils/index.js'
import { OCPPIncomingRequestService } from '../OCPPIncomingRequestService.js'
[OCPP20IncomingRequestCommand.CLEAR_CACHE, super.handleRequestClearCache.bind(this)],
[OCPP20IncomingRequestCommand.GET_BASE_REPORT, this.handleRequestGetBaseReport.bind(this)],
[OCPP20IncomingRequestCommand.GET_VARIABLES, this.handleRequestGetVariables.bind(this)],
+ [OCPP20IncomingRequestCommand.RESET, this.handleRequestReset.bind(this)],
])
this.payloadValidateFunctions = new Map<
OCPP20IncomingRequestCommand,
)
),
],
+ [
+ OCPP20IncomingRequestCommand.RESET,
+ this.ajv.compile(
+ OCPP20ServiceUtils.parseJsonSchemaFile<OCPP20ResetRequest>(
+ 'assets/json-schemas/ocpp/2.0/ResetRequest.json',
+ moduleName,
+ 'constructor'
+ )
+ ),
+ ],
])
// Handle incoming request events
this.on(
}
}
+ private handleRequestReset (
+ chargingStation: ChargingStation,
+ commandPayload: OCPP20ResetRequest
+ ): OCPP20ResetResponse {
+ logger.debug(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Reset request received with type ${commandPayload.type}${commandPayload.evseId !== undefined ? ` for EVSE ${commandPayload.evseId.toString()}` : ''}`
+ )
+
+ const { evseId, type } = commandPayload
+
+ if (evseId !== undefined && evseId > 0) {
+ // Check if the charging station supports EVSE-specific reset
+ if (!chargingStation.hasEvses) {
+ logger.warn(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Charging station does not support EVSE-specific reset`
+ )
+ return {
+ status: ResetStatusEnumType.Rejected,
+ statusInfo: {
+ additionalInfo: 'Charging station does not support resetting individual EVSE',
+ reasonCode: ReasonCodeEnumType.UnsupportedRequest,
+ },
+ }
+ }
+
+ // Check if the EVSE exists
+ const evseExists = chargingStation.evses.has(evseId)
+ if (!evseExists) {
+ logger.warn(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: EVSE ${evseId.toString()} not found, rejecting reset request`
+ )
+ return {
+ status: ResetStatusEnumType.Rejected,
+ statusInfo: {
+ additionalInfo: `EVSE ${evseId.toString()} does not exist on this charging station`,
+ reasonCode: ReasonCodeEnumType.UnknownEvse,
+ },
+ }
+ }
+ }
+
+ // Check for active transactions
+ const hasActiveTransactions = chargingStation.getNumberOfRunningTransactions() > 0
+
+ // Check for EVSE-specific active transactions if evseId is provided
+ let hasEvseActiveTransactions = false
+ if (evseId !== undefined && evseId > 0) {
+ // Check if there are active transactions on the specific EVSE
+ const evse = chargingStation.evses.get(evseId)
+ if (evse) {
+ for (const [, connector] of evse.connectors) {
+ if (connector.transactionId !== undefined) {
+ hasEvseActiveTransactions = true
+ break
+ }
+ }
+ }
+ }
+
+ try {
+ if (type === ResetEnumType.Immediate) {
+ if (evseId !== undefined) {
+ // EVSE-specific immediate reset
+ if (hasEvseActiveTransactions) {
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Immediate EVSE reset with active transaction, will terminate transaction and reset EVSE ${evseId.toString()}`
+ )
+
+ // TODO: Implement EVSE-specific transaction termination
+ // For now, accept and schedule the reset
+ this.scheduleEvseReset(chargingStation, evseId, true)
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ statusInfo: {
+ additionalInfo: `EVSE ${evseId.toString()} reset initiated, active transaction will be terminated`,
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ } else {
+ // Reset EVSE immediately
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Immediate EVSE reset without active transactions for EVSE ${evseId.toString()}`
+ )
+
+ this.scheduleEvseReset(chargingStation, evseId, false)
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ statusInfo: {
+ additionalInfo: `EVSE ${evseId.toString()} reset initiated`,
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ }
+ } else {
+ // Charging station immediate reset
+ if (hasActiveTransactions) {
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Immediate reset with active transactions, will terminate transactions and reset`
+ )
+
+ // TODO: Implement proper transaction termination with TransactionEventRequest
+ // For now, reset immediately and let the reset handle transaction cleanup
+ chargingStation.reset(StopTransactionReason.REMOTE).catch((error: unknown) => {
+ logger.error(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Error during immediate reset:`,
+ error
+ )
+ })
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ statusInfo: {
+ additionalInfo: 'Immediate reset initiated, active transactions will be terminated',
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ } else {
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Immediate reset without active transactions`
+ )
+
+ // TODO: Send StatusNotification(Unavailable) for all connectors
+ chargingStation.reset(StopTransactionReason.REMOTE).catch((error: unknown) => {
+ logger.error(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Error during immediate reset:`,
+ error
+ )
+ })
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ }
+ }
+ }
+ } else {
+ // OnIdle reset
+ if (evseId !== undefined) {
+ // EVSE-specific OnIdle reset
+ if (hasEvseActiveTransactions) {
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: OnIdle EVSE reset scheduled for EVSE ${evseId.toString()}, waiting for transaction completion`
+ )
+
+ // TODO: Implement proper monitoring of EVSE transaction completion
+ this.scheduleEvseResetOnIdle(chargingStation, evseId)
+
+ return {
+ status: ResetStatusEnumType.Scheduled,
+ statusInfo: {
+ additionalInfo: `EVSE ${evseId.toString()} reset scheduled after transaction completion`,
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ } else {
+ // No active transactions on EVSE, reset immediately
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: OnIdle EVSE reset without active transactions for EVSE ${evseId.toString()}`
+ )
+
+ this.scheduleEvseReset(chargingStation, evseId, false)
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ statusInfo: {
+ additionalInfo: `EVSE ${evseId.toString()} reset initiated`,
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ }
+ } else {
+ // Charging station OnIdle reset
+ if (hasActiveTransactions) {
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: OnIdle reset scheduled, waiting for transaction completion`
+ )
+
+ this.scheduleResetOnIdle(chargingStation)
+
+ return {
+ status: ResetStatusEnumType.Scheduled,
+ statusInfo: {
+ additionalInfo: 'Reset scheduled after all transactions complete',
+ reasonCode: ReasonCodeEnumType.NoError,
+ },
+ }
+ } else {
+ // No active transactions, reset immediately
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: OnIdle reset without active transactions, resetting immediately`
+ )
+
+ chargingStation.reset(StopTransactionReason.REMOTE).catch((error: unknown) => {
+ logger.error(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Error during OnIdle reset:`,
+ error
+ )
+ })
+
+ return {
+ status: ResetStatusEnumType.Accepted,
+ }
+ }
+ }
+ }
+ } catch (error) {
+ logger.error(
+ `${chargingStation.logPrefix()} ${moduleName}.handleRequestReset: Error handling reset request:`,
+ error
+ )
+
+ return {
+ status: ResetStatusEnumType.Rejected,
+ statusInfo: {
+ additionalInfo: 'Internal error occurred while processing reset request',
+ reasonCode: ReasonCodeEnumType.InternalError,
+ },
+ }
+ }
+ }
+
+ private scheduleEvseReset (
+ chargingStation: ChargingStation,
+ evseId: number,
+ terminateTransactions: boolean
+ ): void {
+ logger.debug(
+ `${chargingStation.logPrefix()} ${moduleName}.scheduleEvseReset: Scheduling EVSE ${evseId.toString()} reset${terminateTransactions ? ' with transaction termination' : ''}`
+ )
+
+ setTimeout(
+ () => {
+ // TODO: Implement actual EVSE-specific reset logic
+ // This should:
+ // 1. Send StatusNotification(Unavailable) for EVSE connectors (B11.FR.08)
+ // 2. Terminate active transactions if needed
+ // 3. Reset EVSE state
+ // 4. Restore EVSE to appropriate state after reset
+
+ logger.info(
+ `${chargingStation.logPrefix()} ${moduleName}.scheduleEvseReset: EVSE ${evseId.toString()} reset executed`
+ )
+ },
+ terminateTransactions ? 1000 : 100
+ ) // Small delay for immediate execution
+ }
+
+ private scheduleEvseResetOnIdle (chargingStation: ChargingStation, evseId: number): void {
+ logger.debug(
+ `${chargingStation.logPrefix()} ${moduleName}.scheduleEvseResetOnIdle: Monitoring EVSE ${evseId.toString()} for transaction completion`
+ )
+
+ // TODO: Implement proper monitoring logic
+ const checkInterval = setInterval(() => {
+ const evse = chargingStation.evses.get(evseId)
+ if (evse) {
+ let hasActiveTransactions = false
+ for (const [, connector] of evse.connectors) {
+ if (connector.transactionId !== undefined) {
+ hasActiveTransactions = true
+ break
+ }
+ }
+
+ if (!hasActiveTransactions) {
+ clearInterval(checkInterval)
+ this.scheduleEvseReset(chargingStation, evseId, false)
+ }
+ }
+ }, 5000) // Check every 5 seconds
+ }
+
+ private scheduleResetOnIdle (chargingStation: ChargingStation): void {
+ logger.debug(
+ `${chargingStation.logPrefix()} ${moduleName}.scheduleResetOnIdle: Monitoring charging station for transaction completion`
+ )
+
+ // TODO: Implement proper monitoring logic
+ const checkInterval = setInterval(() => {
+ const hasActiveTransactions = chargingStation.getNumberOfRunningTransactions() > 0
+
+ if (!hasActiveTransactions) {
+ clearInterval(checkInterval)
+ // TODO: Use OCPP2 stop transaction reason when implemented
+ chargingStation.reset(StopTransactionReason.REMOTE).catch((error: unknown) => {
+ logger.error(
+ `${chargingStation.logPrefix()} ${moduleName}.scheduleResetOnIdle: Error during scheduled reset:`,
+ error
+ )
+ })
+ }
+ }, 5000) // Check every 5 seconds
+ }
+
private async sendNotifyReportRequest (
chargingStation: ChargingStation,
request: OCPP20GetBaseReportRequest,
chunks.push(reportData.slice(i, i + maxItemsPerMessage))
}
- // Ensure we always send at least one message (even if empty)
+ // Ensure we always send at least one message
if (chunks.length === 0) {
- chunks.push([])
+ chunks.push(undefined) // undefined means reportData will be omitted from the request
}
// Send fragmented NotifyReport messages
const isLastChunk = seqNo === chunks.length - 1
const chunk = chunks[seqNo]
- await chargingStation.ocppRequestService.requestHandler<
- OCPP20NotifyReportRequest,
- OCPP20NotifyReportResponse
- >(chargingStation, OCPP20RequestCommand.NOTIFY_REPORT, {
+ const notifyReportRequest: OCPP20NotifyReportRequest = {
generatedAt: new Date(),
- reportData: chunk,
requestId,
seqNo,
tbc: !isLastChunk,
- })
+ // Only include reportData if chunk is defined and not empty
+ ...(chunk !== undefined && chunk.length > 0 && { reportData: chunk }),
+ }
+
+ await chargingStation.ocppRequestService.requestHandler<
+ OCPP20NotifyReportRequest,
+ OCPP20NotifyReportResponse
+ >(chargingStation, OCPP20RequestCommand.NOTIFY_REPORT, notifyReportRequest)
logger.debug(
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
- `${chargingStation.logPrefix()} ${moduleName}.sendNotifyReportRequest: NotifyReport sent seqNo=${seqNo} for requestId ${requestId} with ${chunk.length} report items (tbc=${!isLastChunk})`
+ `${chargingStation.logPrefix()} ${moduleName}.sendNotifyReportRequest: NotifyReport sent seqNo=${seqNo} for requestId ${requestId} with ${chunk?.length ?? 0} report items (tbc=${!isLastChunk})`
)
}
import {
AttributeEnumType,
type ComponentType,
- GenericDeviceModelStatusEnumType,
GetVariableStatusEnumType,
MutabilityEnumType,
OCPP20ComponentName,
type OCPP20GetVariableResultType,
OCPP20OptionalVariableName,
OCPP20RequiredVariableName,
+ ReasonCodeEnumType,
type VariableType,
} from '../../../types/index.js'
import { Constants, logger } from '../../../utils/index.js'
component: variableData.component,
statusInfo: {
additionalInfo: 'Internal error occurred while retrieving variable',
- reasonCode: GenericDeviceModelStatusEnumType.Rejected,
+ reasonCode: ReasonCodeEnumType.InternalError,
},
variable: variableData.variable,
})
attributeStatus: GetVariableStatusEnumType.UnknownComponent,
attributeStatusInfo: {
additionalInfo: `Component ${component.name} is not supported by this charging station`,
- reasonCode: GenericDeviceModelStatusEnumType.NotSupported,
+ reasonCode: ReasonCodeEnumType.NotFound,
},
attributeType,
component,
attributeStatus: GetVariableStatusEnumType.UnknownVariable,
attributeStatusInfo: {
additionalInfo: `Variable ${variable.name} is not supported for component ${component.name}`,
- reasonCode: GenericDeviceModelStatusEnumType.NotSupported,
+ reasonCode: ReasonCodeEnumType.NotFound,
},
attributeType,
component,
attributeStatus: GetVariableStatusEnumType.NotSupportedAttributeType,
attributeStatusInfo: {
additionalInfo: `Attribute type ${attributeType} is not supported for variable ${variable.name}`,
- reasonCode: GenericDeviceModelStatusEnumType.NotSupported,
+ reasonCode: ReasonCodeEnumType.UnsupportedParam,
},
attributeType,
component,
GenericDeviceModelStatusEnumType,
OCPP20ComponentName,
OCPP20ConnectorStatusEnumType,
+ ReasonCodeEnumType,
ReportBaseEnumType,
type ReportDataType,
+ ResetEnumType,
+ ResetStatusEnumType,
} from './ocpp/2.0/Common.js'
export {
type OCPP20BootNotificationRequest,
OCPP20IncomingRequestCommand,
type OCPP20NotifyReportRequest,
OCPP20RequestCommand,
+ type OCPP20ResetRequest,
type OCPP20StatusNotificationRequest,
} from './ocpp/2.0/Requests.js'
export type {
OCPP20GetVariablesResponse,
OCPP20HeartbeatResponse,
OCPP20NotifyReportResponse,
+ OCPP20ResetResponse,
OCPP20StatusNotificationResponse,
} from './ocpp/2.0/Responses.js'
export {
Operative = 'Operative',
}
+export enum ReasonCodeEnumType {
+ CSNotAccepted = 'CSNotAccepted',
+ DuplicateProfile = 'DuplicateProfile',
+ DuplicateRequestId = 'DuplicateRequestId',
+ FixedCable = 'FixedCable',
+ FwUpdateInProgress = 'FwUpdateInProgress',
+ InternalError = 'InternalError',
+ InvalidCertificate = 'InvalidCertificate',
+ InvalidCSR = 'InvalidCSR',
+ InvalidIdToken = 'InvalidIdToken',
+ InvalidMessageSeq = 'InvalidMessageSeq',
+ InvalidProfile = 'InvalidProfile',
+ InvalidSchedule = 'InvalidSchedule',
+ InvalidStackLevel = 'InvalidStackLevel',
+ InvalidURL = 'InvalidURL',
+ InvalidValue = 'InvalidValue',
+ MissingDevModelInfo = 'MissingDevModelInfo',
+ MissingParam = 'MissingParam',
+ NoCable = 'NoCable',
+ NoError = 'NoError',
+ NotEnabled = 'NotEnabled',
+ NotFound = 'NotFound',
+ OutOfMemory = 'OutOfMemory',
+ OutOfStorage = 'OutOfStorage',
+ ReadOnly = 'ReadOnly',
+ TooLargeElement = 'TooLargeElement',
+ TooManyElements = 'TooManyElements',
+ TxInProgress = 'TxInProgress',
+ TxNotFound = 'TxNotFound',
+ TxStarted = 'TxStarted',
+ UnknownConnectorId = 'UnknownConnectorId',
+ UnknownConnectorType = 'UnknownConnectorType',
+ UnknownEvse = 'UnknownEvse',
+ UnknownTxId = 'UnknownTxId',
+ Unspecified = 'Unspecified',
+ UnsupportedParam = 'UnsupportedParam',
+ UnsupportedRateUnit = 'UnsupportedRateUnit',
+ UnsupportedRequest = 'UnsupportedRequest',
+ ValueOutOfRange = 'ValueOutOfRange',
+ ValuePositiveOnly = 'ValuePositiveOnly',
+ ValueTooHigh = 'ValueTooHigh',
+ ValueTooLow = 'ValueTooLow',
+ ValueZeroNotAllowed = 'ValueZeroNotAllowed',
+ WriteOnly = 'WriteOnly',
+}
+
export enum ReportBaseEnumType {
ConfigurationInventory = 'ConfigurationInventory',
FullInventory = 'FullInventory',
SummaryInventory = 'SummaryInventory',
}
+export enum ResetEnumType {
+ Immediate = 'Immediate',
+ OnIdle = 'OnIdle',
+}
+
+export enum ResetStatusEnumType {
+ Accepted = 'Accepted',
+ Rejected = 'Rejected',
+ Scheduled = 'Scheduled',
+}
+
export interface CertificateHashDataChainType extends JsonObject {
certificateHashData: CertificateHashDataType
certificateType: GetCertificateIdUseEnumType
export interface StatusInfoType extends JsonObject {
additionalInfo?: string
customData?: CustomDataType
- reasonCode: string
+ reasonCode: ReasonCodeEnumType
}
interface EVSEType extends JsonObject {
OCPP20ConnectorStatusEnumType,
ReportBaseEnumType,
ReportDataType,
+ ResetEnumType,
} from './Common.js'
import type { OCPP20GetVariableDataType, OCPP20SetVariableDataType } from './Variables.js'
GET_VARIABLES = 'GetVariables',
REQUEST_START_TRANSACTION = 'RequestStartTransaction',
REQUEST_STOP_TRANSACTION = 'RequestStopTransaction',
+ RESET = 'Reset',
}
export enum OCPP20RequestCommand {
tbc?: boolean
}
+export interface OCPP20ResetRequest extends JsonObject {
+ evseId?: number
+ type: ResetEnumType
+}
+
export interface OCPP20SetVariablesRequest extends JsonObject {
setVariableData: OCPP20SetVariableDataType[]
}
GenericDeviceModelStatusEnumType,
GenericStatusEnumType,
InstallCertificateStatusEnumType,
+ ResetStatusEnumType,
StatusInfoType,
} from './Common.js'
import type { OCPP20GetVariableResultType, OCPP20SetVariableResultType } from './Variables.js'
export type OCPP20NotifyReportResponse = EmptyObject
+export interface OCPP20ResetResponse extends JsonObject {
+ status: ResetStatusEnumType
+ statusInfo?: StatusInfoType
+}
+
export interface OCPP20SetVariablesResponse extends JsonObject {
setVariableResult: OCPP20SetVariableResultType[]
}
import { createChargingStationWithEvses } from '../../../ChargingStationFactory.js'
import { TEST_CHARGING_STATION_NAME } from './OCPP20TestConstants.js'
-await describe('OCPP20IncomingRequestService ClearCache integration tests', async () => {
+await describe('C11 - Clear Authorization Data in Authorization Cache', async () => {
const mockChargingStation = createChargingStationWithEvses({
baseName: TEST_CHARGING_STATION_NAME,
heartbeatInterval: Constants.DEFAULT_HEARTBEAT_INTERVAL,
TEST_FIRMWARE_VERSION,
} from './OCPP20TestConstants.js'
-await describe('OCPP20IncomingRequestService GetBaseReport integration tests', async () => {
+await describe('B07 - Get Base Report', async () => {
const mockChargingStation = createChargingStationWithEvses({
baseName: TEST_CHARGING_STATION_NAME,
heartbeatInterval: Constants.DEFAULT_HEARTBEAT_INTERVAL,
TEST_CONNECTOR_VALID_INSTANCE,
} from './OCPP20TestConstants.js'
-await describe('OCPP20IncomingRequestService GetVariables integration tests', async () => {
+await describe('B06 - Get Variables', async () => {
const mockChargingStation = createChargingStationWithEvses({
baseName: TEST_CHARGING_STATION_NAME,
heartbeatInterval: Constants.DEFAULT_HEARTBEAT_INTERVAL,
--- /dev/null
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { expect } from '@std/expect'
+import { describe, it } from 'node:test'
+
+import { OCPP20IncomingRequestService } from '../../../../src/charging-station/ocpp/2.0/OCPP20IncomingRequestService.js'
+import {
+ type OCPP20ResetRequest,
+ type OCPP20ResetResponse,
+ ReasonCodeEnumType,
+ ResetEnumType,
+ ResetStatusEnumType,
+} from '../../../../src/types/index.js'
+import { Constants } from '../../../../src/utils/index.js'
+import { createChargingStationWithEvses } from '../../../ChargingStationFactory.js'
+import { TEST_CHARGING_STATION_NAME } from './OCPP20TestConstants.js'
+
+await describe('B11 & B12 - Reset', async () => {
+ const mockChargingStation = createChargingStationWithEvses({
+ baseName: TEST_CHARGING_STATION_NAME,
+ heartbeatInterval: Constants.DEFAULT_HEARTBEAT_INTERVAL,
+ stationInfo: {
+ ocppStrictCompliance: false,
+ resetTime: 5000,
+ },
+ websocketPingInterval: Constants.DEFAULT_WEBSOCKET_PING_INTERVAL,
+ })
+
+ // Add missing method to mock
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 0
+ ;(mockChargingStation as any).reset = () => Promise.resolve()
+
+ const incomingRequestService = new OCPP20IncomingRequestService()
+
+ await describe('B11 - Reset - Without Ongoing Transaction', async () => {
+ await it('B11.FR.01 - Should handle Reset request with Immediate type when no transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(typeof response).toBe('object')
+ expect(response.status).toBeDefined()
+ expect(typeof response.status).toBe('string')
+ expect([
+ ResetStatusEnumType.Accepted,
+ ResetStatusEnumType.Rejected,
+ ResetStatusEnumType.Scheduled,
+ ]).toContain(response.status)
+ })
+
+ await it('B11.FR.01 - Should handle Reset request with OnIdle type when no transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.OnIdle,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBeDefined()
+ expect([
+ ResetStatusEnumType.Accepted,
+ ResetStatusEnumType.Rejected,
+ ResetStatusEnumType.Scheduled,
+ ]).toContain(response.status)
+ })
+
+ await it('B11.FR.03+ - Should handle EVSE-specific reset request when no transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 1,
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBeDefined()
+ expect([
+ ResetStatusEnumType.Accepted,
+ ResetStatusEnumType.Rejected,
+ ResetStatusEnumType.Scheduled,
+ ]).toContain(response.status)
+ })
+
+ await it('B11.FR.03+ - Should reject reset for non-existent EVSE when no transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 999, // Non-existent EVSE
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Rejected)
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.UnknownEvse)
+ expect(response.statusInfo?.additionalInfo).toContain('EVSE 999')
+ })
+
+ await it('B11.FR.01+ - Should return proper response structure for immediate reset without transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBeDefined()
+ expect(typeof response.status).toBe('string')
+
+ // For immediate reset without active transactions, should be accepted
+ if (mockChargingStation.getNumberOfRunningTransactions() === 0) {
+ expect(response.status).toBe(ResetStatusEnumType.Accepted)
+ }
+ })
+
+ await it('B11.FR.01+ - Should return proper response structure for OnIdle reset without transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.OnIdle,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Accepted)
+ })
+
+ await it('B11.FR.03+ - Should reject EVSE reset when not supported and no transactions', async () => {
+ // Mock charging station without EVSE support
+ const originalHasEvses = mockChargingStation.hasEvses
+ ;(mockChargingStation as any).hasEvses = false
+
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 1,
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Rejected)
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.UnsupportedRequest)
+ expect(response.statusInfo?.additionalInfo).toContain(
+ 'does not support resetting individual EVSE'
+ )
+
+ // Restore original state
+ ;(mockChargingStation as any).hasEvses = originalHasEvses
+ })
+
+ await it('B11.FR.03+ - Should handle EVSE-specific reset without transactions', async () => {
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 1,
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Accepted)
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.NoError)
+ expect(response.statusInfo?.additionalInfo).toContain('EVSE 1 reset initiated')
+ })
+ })
+
+ await describe('B12 - Reset - With Ongoing Transaction', async () => {
+ await it('B12.FR.02 - Should handle immediate reset with active transactions', async () => {
+ // Mock active transactions
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 1
+
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Accepted) // Should accept immediate reset
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.NoError)
+ expect(response.statusInfo?.additionalInfo).toContain(
+ 'active transactions will be terminated'
+ )
+
+ // Reset mock
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 0
+ })
+
+ await it('B12.FR.01 - Should handle OnIdle reset with active transactions', async () => {
+ // Mock active transactions
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 1
+
+ const resetRequest: OCPP20ResetRequest = {
+ type: ResetEnumType.OnIdle,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Scheduled) // Should schedule OnIdle reset
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.NoError)
+ expect(response.statusInfo?.additionalInfo).toContain(
+ 'scheduled after all transactions complete'
+ )
+
+ // Reset mock
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 0
+ })
+
+ await it('B12.FR.03+ - Should handle EVSE-specific reset with active transactions', async () => {
+ // Mock active transactions
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 1
+
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 1,
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBeDefined()
+ expect([ResetStatusEnumType.Accepted, ResetStatusEnumType.Scheduled]).toContain(
+ response.status
+ )
+
+ // Reset mock
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 0
+ })
+
+ await it('B12.FR.03+ - Should reject EVSE reset when not supported with active transactions', async () => {
+ // Mock charging station without EVSE support and active transactions
+ const originalHasEvses = mockChargingStation.hasEvses
+ ;(mockChargingStation as any).hasEvses = false
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 1
+
+ const resetRequest: OCPP20ResetRequest = {
+ evseId: 1,
+ type: ResetEnumType.Immediate,
+ }
+
+ const response: OCPP20ResetResponse = await (
+ incomingRequestService as any
+ ).handleRequestReset(mockChargingStation, resetRequest)
+
+ expect(response).toBeDefined()
+ expect(response.status).toBe(ResetStatusEnumType.Rejected)
+ expect(response.statusInfo).toBeDefined()
+ expect(response.statusInfo?.reasonCode).toBe(ReasonCodeEnumType.UnsupportedRequest)
+ expect(response.statusInfo?.additionalInfo).toContain(
+ 'does not support resetting individual EVSE'
+ )
+
+ // Restore original state
+ ;(mockChargingStation as any).hasEvses = originalHasEvses
+ ;(mockChargingStation as any).getNumberOfRunningTransactions = () => 0
+ })
+ })
+})
TEST_FIRMWARE_VERSION,
} from './OCPP20TestConstants.js'
-await describe('OCPP20RequestService BootNotification integration tests', async () => {
+await describe('B01 - Cold Boot Charging Station', async () => {
const mockResponseService = new OCPP20ResponseService()
const requestService = new OCPP20RequestService(mockResponseService)
TEST_FIRMWARE_VERSION,
} from './OCPP20TestConstants.js'
-await describe('OCPP20RequestService HeartBeat integration tests', async () => {
+await describe('G02 - Heartbeat', async () => {
const mockResponseService = new OCPP20ResponseService()
const requestService = new OCPP20RequestService(mockResponseService)
TEST_FIRMWARE_VERSION,
} from './OCPP20TestConstants.js'
-await describe('OCPP20RequestService NotifyReport integration tests', async () => {
+await describe('B07 - Get Base Report (NotifyReport)', async () => {
const mockResponseService = new OCPP20ResponseService()
const requestService = new OCPP20RequestService(mockResponseService)
TEST_STATUS_CHARGING_STATION_NAME,
} from './OCPP20TestConstants.js'
-await describe('OCPP20RequestService StatusNotification integration tests', async () => {
+await describe('G01 - Status Notification', async () => {
const mockResponseService = new OCPP20ResponseService()
const requestService = new OCPP20RequestService(mockResponseService)
type OCPP20GetVariableDataType,
OCPP20OptionalVariableName,
OCPP20RequiredVariableName,
+ ReasonCodeEnumType,
type VariableType,
} from '../../../../src/types/index.js'
import { Constants } from '../../../../src/utils/index.js'
expect(result[0].component.name).toBe('InvalidComponent')
expect(result[0].variable.name).toBe('SomeVariable')
expect(result[0].attributeStatusInfo).toBeDefined()
- expect(result[0].attributeStatusInfo?.reasonCode).toBe('NotSupported')
+ expect(result[0].attributeStatusInfo?.reasonCode).toBe(ReasonCodeEnumType.NotFound)
expect(result[0].attributeStatusInfo?.additionalInfo).toContain(
'Component InvalidComponent is not supported'
)
expect(result[0].component.name).toBe(OCPP20ComponentName.ChargingStation)
expect(result[0].variable.name).toBe('InvalidVariable')
expect(result[0].attributeStatusInfo).toBeDefined()
- expect(result[0].attributeStatusInfo?.reasonCode).toBe('NotSupported')
+ expect(result[0].attributeStatusInfo?.reasonCode).toBe(ReasonCodeEnumType.NotFound)
expect(result[0].attributeStatusInfo?.additionalInfo).toContain(
'Variable InvalidVariable is not supported'
)
expect(result[0].component.name).toBe(OCPP20ComponentName.ChargingStation)
expect(result[0].variable.name).toBe(OCPP20OptionalVariableName.HeartbeatInterval)
expect(result[0].attributeStatusInfo).toBeDefined()
- expect(result[0].attributeStatusInfo?.reasonCode).toBe('NotSupported')
+ expect(result[0].attributeStatusInfo?.reasonCode).toBe(ReasonCodeEnumType.UnsupportedParam)
expect(result[0].attributeStatusInfo?.additionalInfo).toContain(
'Attribute type Target is not supported'
)
expect(result[0].component.instance).toBe('999')
expect(result[0].variable.name).toBe(OCPP20RequiredVariableName.AuthorizeRemoteStart)
expect(result[0].attributeStatusInfo).toBeDefined()
- expect(result[0].attributeStatusInfo?.reasonCode).toBe('NotSupported')
+ expect(result[0].attributeStatusInfo?.reasonCode).toBe(ReasonCodeEnumType.NotFound)
expect(result[0].attributeStatusInfo?.additionalInfo).toContain(
'Component Connector is not supported'
)
await it('Verify sleep()', async () => {
const start = performance.now()
- const delay = 1000
+ const delay = 10
const timeout = await sleep(delay)
const stop = performance.now()
const actualDelay = stop - start
expect(timeout).toBeDefined()
expect(typeof timeout).toBe('object')
- expect(actualDelay).toBeGreaterThanOrEqual(delay)
+ expect(actualDelay).toBeGreaterThanOrEqual(delay - 0.5) // Allow 0.5ms tolerance
expect(actualDelay).toBeLessThan(delay + 50) // Allow 50ms tolerance
clearTimeout(timeout)
})
expect(typeof timeout).toBe('object')
// Verify actual delay is approximately correct (within reasonable tolerance)
- expect(actualDelay).toBeGreaterThanOrEqual(delay)
- expect(actualDelay).toBeLessThan(delay + 50) // Allow 50ms tolerance for system variance
+ expect(actualDelay).toBeGreaterThanOrEqual(delay - 0.5) // Allow 0.5ms tolerance
+ expect(actualDelay).toBeLessThan(delay + 50) // Allow 50ms tolerance
// Clean up timeout
clearTimeout(timeout)
repositories / e-mobility-charging-stations-simulator.git / commitdiff
