Developer
813 lines
22 KiB
ObjectPascal
813 lines
22 KiB
ObjectPascal
unit uUnitTests;
|
|
|
|
interface
|
|
|
|
uses
|
|
TestFramework, SysUtils, Classes, System.JSON, uExceptionHandler, uLogManager,
|
|
uConfigManager, uBusinessServices, uCommonUtils;
|
|
|
|
type
|
|
TTestExceptionHandler = class(TTestCase)
|
|
published
|
|
procedure TestBaseException;
|
|
procedure TestNetworkException;
|
|
procedure TestDataException;
|
|
procedure TestBusinessException;
|
|
procedure TestDeviceException;
|
|
procedure TestValidationException;
|
|
procedure TestExceptionHandler;
|
|
end;
|
|
|
|
TTestLogManager = class(TTestCase)
|
|
published
|
|
procedure TestLogLevels;
|
|
procedure TestLogCategories;
|
|
procedure TestPerformanceLogger;
|
|
procedure TestLogExport;
|
|
procedure TestUIMonitoring;
|
|
procedure TestNetworkMonitoring;
|
|
procedure TestFormMonitoring;
|
|
procedure TestDataOperationMonitoring;
|
|
procedure TestLogCategoriesFilter;
|
|
end;
|
|
|
|
TTestConfigManager = class(TTestCase)
|
|
published
|
|
procedure TestConfigLoading;
|
|
procedure TestConfigSaving;
|
|
procedure TestConfigTypes;
|
|
procedure TestAppConfig;
|
|
procedure TestAppConfigExtended;
|
|
procedure TestConfigArrayAndObject;
|
|
end;
|
|
|
|
TTestBusinessServices = class(TTestCase)
|
|
published
|
|
procedure TestAuthService;
|
|
procedure TestAuthServiceLogout;
|
|
procedure TestAuthServiceRefreshToken;
|
|
procedure TestWorkOrderService;
|
|
procedure TestWorkOrderServiceCreate;
|
|
procedure TestWorkOrderServiceUpdateStatus;
|
|
procedure TestWorkOrderServiceReportProduction;
|
|
procedure TestDeviceService;
|
|
procedure TestDeviceServiceConnectDisconnect;
|
|
procedure TestDeviceServiceSendCommand;
|
|
procedure TestSyncService;
|
|
procedure TestSyncServiceBatch;
|
|
procedure TestSyncServiceRetry;
|
|
procedure TestProductionReportingService;
|
|
procedure TestProductionReportingServiceValidateUser;
|
|
procedure TestProductionReportingServiceGetWorkOrderInfo;
|
|
procedure TestProductionReportingServiceGetProcessList;
|
|
procedure TestProductionReportingServiceValidateGoodsNo;
|
|
procedure TestProductionReportingServiceSubmitData;
|
|
procedure TestDeviceConfigService;
|
|
procedure TestDataAccessService;
|
|
end;
|
|
|
|
TTestCommonUtils = class(TTestCase)
|
|
published
|
|
procedure TestValidator;
|
|
procedure TestStringHelper;
|
|
procedure TestDateTimeHelper;
|
|
procedure TestFileHelper;
|
|
procedure TestJSONHelper;
|
|
end;
|
|
|
|
implementation
|
|
|
|
{ TTestExceptionHandler }
|
|
|
|
procedure TTestExceptionHandler.TestBaseException;
|
|
var
|
|
Ex: EBaseException;
|
|
JSON: TJSONObject;
|
|
begin
|
|
Ex := EBaseException.Create('Test exception', 1001, 'Test');
|
|
try
|
|
CheckEquals('Test exception', Ex.Message);
|
|
CheckEquals(1001, Ex.ErrorCode);
|
|
CheckEquals('Test', Ex.ErrorType);
|
|
JSON := Ex.ToJSON;
|
|
try
|
|
CheckNotNull(JSON);
|
|
CheckEquals('Test exception', JSON.GetValue('message').Value);
|
|
finally
|
|
JSON.Free;
|
|
end;
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestNetworkException;
|
|
var
|
|
Ex: ENetworkException;
|
|
begin
|
|
Ex := ENetworkException.Create('Network error', 2001);
|
|
try
|
|
CheckEquals('Network error', Ex.Message);
|
|
CheckEquals(2001, Ex.ErrorCode);
|
|
CheckEquals('Network', Ex.ErrorType);
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestDataException;
|
|
var
|
|
Ex: EDataException;
|
|
begin
|
|
Ex := EDataException.Create('Data error', 3001);
|
|
try
|
|
CheckEquals('Data error', Ex.Message);
|
|
CheckEquals(3001, Ex.ErrorCode);
|
|
CheckEquals('Data', Ex.ErrorType);
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestBusinessException;
|
|
var
|
|
Ex: EBusinessException;
|
|
begin
|
|
Ex := EBusinessException.Create('Business error', 4001);
|
|
try
|
|
CheckEquals('Business error', Ex.Message);
|
|
CheckEquals(4001, Ex.ErrorCode);
|
|
CheckEquals('Business', Ex.ErrorType);
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestDeviceException;
|
|
var
|
|
Ex: EDeviceException;
|
|
begin
|
|
Ex := EDeviceException.Create('Device error', 5001);
|
|
try
|
|
CheckEquals('Device error', Ex.Message);
|
|
CheckEquals(5001, Ex.ErrorCode);
|
|
CheckEquals('Device', Ex.ErrorType);
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestValidationException;
|
|
var
|
|
Ex: EValidationException;
|
|
begin
|
|
Ex := EValidationException.Create('Field', 'Value', 'Validation error');
|
|
try
|
|
CheckEquals('Validation error', Ex.Message);
|
|
CheckEquals('Field', Ex.FieldName);
|
|
CheckEquals('Value', Ex.FieldValue);
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestExceptionHandler.TestExceptionHandler;
|
|
var
|
|
Handler: TExceptionHandler;
|
|
Ex: Exception;
|
|
begin
|
|
Handler := TExceptionHandler.Create;
|
|
try
|
|
Ex := Exception.Create('Test exception');
|
|
try
|
|
Handler.HandleException(Ex);
|
|
// 验证没有异常抛出
|
|
finally
|
|
Ex.Free;
|
|
end;
|
|
finally
|
|
Handler.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TTestLogManager }
|
|
|
|
procedure TTestLogManager.TestLogLevels;
|
|
begin
|
|
LogManager.Trace('Test trace');
|
|
LogManager.Debug('Test debug');
|
|
LogManager.Info('Test info');
|
|
LogManager.Warn('Test warn');
|
|
LogManager.Error('Test error');
|
|
LogManager.Fatal('Test fatal');
|
|
// 验证没有异常抛出
|
|
end;
|
|
|
|
procedure TTestLogManager.TestLogCategories;
|
|
begin
|
|
LogManager.TraceCategory(lcSystem, 'Test system');
|
|
LogManager.DebugCategory(lcNetwork, 'Test network');
|
|
LogManager.InfoCategory(lcDatabase, 'Test database');
|
|
LogManager.WarnCategory(lcBusiness, 'Test business');
|
|
LogManager.ErrorCategory(lcDevice, 'Test device');
|
|
LogManager.FatalCategory(lcUI, 'Test UI');
|
|
// 验证没有异常抛出
|
|
end;
|
|
|
|
procedure TTestLogManager.TestPerformanceLogger;
|
|
var
|
|
Logger: TPerformanceLogger;
|
|
StartTime: TDateTime;
|
|
Elapsed: Integer;
|
|
begin
|
|
StartTime := Now;
|
|
Logger := TPerformanceLogger.Create('Test operation');
|
|
try
|
|
// 模拟操作
|
|
Sleep(100);
|
|
finally
|
|
Logger.Free;
|
|
end;
|
|
Elapsed := MilliSecondsBetween(Now, StartTime);
|
|
Check(Elapsed >= 100, 'Performance logger should record time');
|
|
end;
|
|
|
|
procedure TTestLogManager.TestLogExport;
|
|
var
|
|
JSONArray: TJSONArray;
|
|
begin
|
|
LogManager.Info('Test log for export');
|
|
JSONArray := LogManager.ExportToJSON;
|
|
try
|
|
CheckNotNull(JSONArray);
|
|
Check(JSONArray.Count > 0, 'Log export should return data');
|
|
finally
|
|
JSONArray.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestLogManager.TestUIMonitoring;
|
|
begin
|
|
LogManager.LogUIOperation('Click', 'Button1', 50);
|
|
LogManager.LogUIOperation('Select', 'ComboBox1', -1);
|
|
Check(True, 'UI monitoring should not throw exception');
|
|
end;
|
|
|
|
procedure TTestLogManager.TestNetworkMonitoring;
|
|
begin
|
|
LogManager.LogNetworkRequest('http://example.com/api', 'GET', 200, 150);
|
|
LogManager.LogNetworkRequest('http://example.com/api', 'POST', 201, 200);
|
|
LogManager.LogNetworkRequest('http://example.com/api', 'GET', 404, 100);
|
|
LogManager.LogNetworkRequest('http://example.com/api', 'POST', 500, 300);
|
|
Check(True, 'Network monitoring should not throw exception');
|
|
end;
|
|
|
|
procedure TTestLogManager.TestFormMonitoring;
|
|
begin
|
|
LogManager.LogFormShow('MainForm', 100);
|
|
LogManager.LogFormShow('LoginForm', -1);
|
|
LogManager.LogFormClose('MainForm', 50);
|
|
LogManager.LogFormClose('LoginForm', -1);
|
|
Check(True, 'Form monitoring should not throw exception');
|
|
end;
|
|
|
|
procedure TTestLogManager.TestDataOperationMonitoring;
|
|
begin
|
|
LogManager.LogDataOperation('INSERT', 10, 25);
|
|
LogManager.LogDataOperation('UPDATE', 5, -1);
|
|
LogManager.LogDataOperation('DELETE', 3, 15);
|
|
Check(True, 'Data operation monitoring should not throw exception');
|
|
end;
|
|
|
|
procedure TTestLogManager.TestLogCategoriesFilter;
|
|
var
|
|
Logs: TArray<TLogEntry>;
|
|
begin
|
|
LogManager.ClearLogs;
|
|
LogManager.InfoCategory(lcBusiness, 'Business log 1');
|
|
LogManager.InfoCategory(lcDevice, 'Device log 1');
|
|
LogManager.InfoCategory(lcNetwork, 'Network log 1');
|
|
Logs := LogManager.GetLogs(llInfo, [lcBusiness, lcDevice]);
|
|
Check(Length(Logs) >= 0, 'Should return filtered logs');
|
|
end;
|
|
|
|
{ TTestConfigManager }
|
|
|
|
procedure TTestConfigManager.TestConfigLoading;
|
|
var
|
|
Config: TConfigManager;
|
|
Value: string;
|
|
begin
|
|
Config := TConfigManager.Create('test_config.ini');
|
|
try
|
|
Value := Config.GetString('Test', 'Key', 'Default');
|
|
CheckEquals('Default', Value);
|
|
finally
|
|
Config.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestConfigManager.TestConfigSaving;
|
|
var
|
|
Config: TConfigManager;
|
|
Value: string;
|
|
begin
|
|
Config := TConfigManager.Create('test_config.ini');
|
|
try
|
|
Config.SetString('Test', 'Key', 'Value');
|
|
Config.Save;
|
|
// 重新加载验证
|
|
Config.Load;
|
|
Value := Config.GetString('Test', 'Key', 'Default');
|
|
CheckEquals('Value', Value);
|
|
finally
|
|
Config.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestConfigManager.TestConfigTypes;
|
|
var
|
|
Config: TConfigManager;
|
|
StrValue: string;
|
|
IntValue: Integer;
|
|
BoolValue: Boolean;
|
|
FloatValue: Double;
|
|
begin
|
|
Config := TConfigManager.Create('test_config.ini');
|
|
try
|
|
Config.SetString('Test', 'String', 'Hello');
|
|
Config.SetInteger('Test', 'Integer', 123);
|
|
Config.SetBoolean('Test', 'Boolean', True);
|
|
Config.SetFloat('Test', 'Float', 123.45);
|
|
|
|
StrValue := Config.GetString('Test', 'String', 'Default');
|
|
IntValue := Config.GetInteger('Test', 'Integer', 0);
|
|
BoolValue := Config.GetBoolean('Test', 'Boolean', False);
|
|
FloatValue := Config.GetFloat('Test', 'Float', 0.0);
|
|
|
|
CheckEquals('Hello', StrValue);
|
|
CheckEquals(123, IntValue);
|
|
CheckEquals(True, BoolValue);
|
|
CheckEquals(123.45, FloatValue, 0.01);
|
|
finally
|
|
Config.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestConfigManager.TestAppConfig;
|
|
begin
|
|
CheckNotNull(Config, 'App config should be created');
|
|
CheckNotNull(Config.GetServerURL, 'Server URL should be set');
|
|
Check(Config.GetServerPort > 0, 'Server port should be valid');
|
|
Check(Config.GetTimeout > 0, 'Timeout should be valid');
|
|
end;
|
|
|
|
procedure TTestConfigManager.TestAppConfigExtended;
|
|
begin
|
|
CheckNotNull(Config.GetFileServerPath, 'File server path should be set');
|
|
CheckNotNull(Config.GetBackupServerPath, 'Backup server path should be set');
|
|
Check(Config.GetSyncInterval > 0, 'Sync interval should be valid');
|
|
Check(Config.GetMaxRetryCount > 0, 'Max retry count should be valid');
|
|
Check(Config.GetLogFileMaxSize > 0, 'Log file max size should be valid');
|
|
end;
|
|
|
|
procedure TTestConfigManager.TestConfigArrayAndObject;
|
|
var
|
|
Config: TConfigManager;
|
|
ArrayValue: TArray<string>;
|
|
begin
|
|
Config := TConfigManager.Create('test_config.ini');
|
|
try
|
|
SetLength(ArrayValue, 3);
|
|
ArrayValue[0] := 'item1';
|
|
ArrayValue[1] := 'item2';
|
|
ArrayValue[2] := 'item3';
|
|
Config.SetArray('Test', 'Array', ArrayValue);
|
|
|
|
ArrayValue := Config.GetArray('Test', 'Array', []);
|
|
Check(Length(ArrayValue) = 3, 'Array should have 3 items');
|
|
CheckEquals('item1', ArrayValue[0]);
|
|
CheckEquals('item2', ArrayValue[1]);
|
|
CheckEquals('item3', ArrayValue[2]);
|
|
finally
|
|
Config.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TTestBusinessServices }
|
|
|
|
procedure TTestBusinessServices.TestAuthService;
|
|
var
|
|
AuthService: TAuthService;
|
|
Result: TAuthResult;
|
|
begin
|
|
AuthService := TAuthService.Create;
|
|
try
|
|
Result := AuthService.Login('test', 'test');
|
|
Check(Result.Success, 'Login should succeed');
|
|
CheckNotNull(Result.Token, 'Token should be returned');
|
|
finally
|
|
AuthService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestWorkOrderService;
|
|
var
|
|
WorkOrderService: TWorkOrderService;
|
|
Orders: TArray<TWorkOrderInfo>;
|
|
begin
|
|
WorkOrderService := TWorkOrderService.Create('test-token');
|
|
try
|
|
Orders := WorkOrderService.GetWorkOrderList;
|
|
Check(Length(Orders) >= 0, 'Work order list should be returned');
|
|
finally
|
|
WorkOrderService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestDeviceService;
|
|
var
|
|
DeviceService: TDeviceService;
|
|
Status: TDeviceStatus;
|
|
Devices: TArray<TDeviceStatus>;
|
|
begin
|
|
DeviceService := TDeviceService.Create;
|
|
try
|
|
Status := DeviceService.GetDeviceStatus('PLC-001');
|
|
Check(Status.DeviceID = 'PLC-001', 'Device status should be returned');
|
|
|
|
Devices := DeviceService.GetAllDevices;
|
|
Check(Length(Devices) >= 0, 'Device list should be returned');
|
|
finally
|
|
DeviceService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestSyncService;
|
|
var
|
|
SyncService: TSyncService;
|
|
Data: TJSONObject;
|
|
Result: Boolean;
|
|
begin
|
|
SyncService := TSyncService.Create('test-token');
|
|
try
|
|
Data := TJSONObject.Create;
|
|
try
|
|
Data.AddPair('test', 'value');
|
|
Result := SyncService.SyncData(Data);
|
|
Check(Result, 'Sync should succeed');
|
|
finally
|
|
Data.Free;
|
|
end;
|
|
finally
|
|
SyncService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestAuthServiceLogout;
|
|
var
|
|
AuthService: TAuthService;
|
|
Result: Boolean;
|
|
begin
|
|
AuthService := TAuthService.Create;
|
|
try
|
|
Result := AuthService.Logout('test-token');
|
|
Check(Result, 'Logout should succeed');
|
|
finally
|
|
AuthService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestAuthServiceRefreshToken;
|
|
var
|
|
AuthService: TAuthService;
|
|
NewToken: string;
|
|
begin
|
|
AuthService := TAuthService.Create;
|
|
try
|
|
NewToken := AuthService.RefreshToken('old-token');
|
|
CheckNotNull(NewToken, 'Refreshed token should be returned');
|
|
CheckNotSame('old-token', NewToken, 'Token should be different');
|
|
finally
|
|
AuthService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestWorkOrderServiceCreate;
|
|
var
|
|
WorkOrderService: TWorkOrderService;
|
|
OrderInfo: TWorkOrderInfo;
|
|
NewOrderID: string;
|
|
begin
|
|
WorkOrderService := TWorkOrderService.Create('test-token');
|
|
try
|
|
OrderInfo.Clear;
|
|
OrderInfo.OrderNumber := 'WO-NEW-001';
|
|
OrderInfo.MaterialID := 'MAT-001';
|
|
OrderInfo.MaterialName := 'Test Material';
|
|
OrderInfo.Quantity := 100;
|
|
NewOrderID := WorkOrderService.CreateWorkOrder(OrderInfo);
|
|
CheckNotNull(NewOrderID, 'New order ID should be returned');
|
|
finally
|
|
WorkOrderService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestWorkOrderServiceUpdateStatus;
|
|
var
|
|
WorkOrderService: TWorkOrderService;
|
|
Result: Boolean;
|
|
begin
|
|
WorkOrderService := TWorkOrderService.Create('test-token');
|
|
try
|
|
Result := WorkOrderService.UpdateWorkOrderStatus('WO-001', 'Completed');
|
|
Check(Result, 'Update status should succeed');
|
|
finally
|
|
WorkOrderService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestWorkOrderServiceReportProduction;
|
|
var
|
|
WorkOrderService: TWorkOrderService;
|
|
Result: Boolean;
|
|
begin
|
|
WorkOrderService := TWorkOrderService.Create('test-token');
|
|
try
|
|
Result := WorkOrderService.ReportProduction('WO-001', 'Process-001', '50');
|
|
Check(Result, 'Report production should succeed');
|
|
finally
|
|
WorkOrderService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestDeviceServiceConnectDisconnect;
|
|
var
|
|
DeviceService: TDeviceService;
|
|
Result: Boolean;
|
|
begin
|
|
DeviceService := TDeviceService.Create;
|
|
try
|
|
Result := DeviceService.ConnectDevice('PLC-001');
|
|
Check(Result, 'Connect device should succeed');
|
|
|
|
Result := DeviceService.DisconnectDevice('PLC-001');
|
|
Check(Result, 'Disconnect device should succeed');
|
|
finally
|
|
DeviceService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestDeviceServiceSendCommand;
|
|
var
|
|
DeviceService: TDeviceService;
|
|
Response: string;
|
|
begin
|
|
DeviceService := TDeviceService.Create;
|
|
try
|
|
Response := DeviceService.SendCommand('PLC-001', 'READ_D100');
|
|
CheckNotNull(Response, 'Command response should be returned');
|
|
Check(Response <> '', 'Command response should not be empty');
|
|
finally
|
|
DeviceService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestSyncServiceBatch;
|
|
var
|
|
SyncService: TSyncService;
|
|
DataArray: TJSONArray;
|
|
Result: Boolean;
|
|
begin
|
|
SyncService := TSyncService.Create('test-token');
|
|
try
|
|
DataArray := TJSONArray.Create;
|
|
try
|
|
DataArray.AddElement(TJSONObject.Create.AddPair('key', 'value1'));
|
|
DataArray.AddElement(TJSONObject.Create.AddPair('key', 'value2'));
|
|
Result := SyncService.SyncBatchData(DataArray);
|
|
Check(Result, 'Batch sync should succeed');
|
|
finally
|
|
DataArray.Free;
|
|
end;
|
|
finally
|
|
SyncService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestSyncServiceRetry;
|
|
var
|
|
SyncService: TSyncService;
|
|
RetryCount: Integer;
|
|
begin
|
|
SyncService := TSyncService.Create('test-token');
|
|
try
|
|
RetryCount := SyncService.RetryFailedSyncs;
|
|
Check(RetryCount >= 0, 'Retry count should be non-negative');
|
|
finally
|
|
SyncService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingService;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
Result: Boolean;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
Result := ProductionService.ReportProduction('WO-001', 'Process-001', '50', 'LOT-001');
|
|
Check(Result, 'Report production should succeed');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingServiceValidateUser;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
Result: Boolean;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
Result := ProductionService.ValidateUser('test-user');
|
|
Check(Result, 'Validate user should succeed');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingServiceGetWorkOrderInfo;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
WorkOrderInfo: TJSONObject;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
WorkOrderInfo := ProductionService.GetWorkOrderInfo('LOT-001');
|
|
CheckNotNull(WorkOrderInfo, 'Work order info should be returned');
|
|
CheckNotNull(WorkOrderInfo.GetValue('lotNo'), 'Lot number should be present');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingServiceGetProcessList;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
ProcessList: TJSONArray;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
ProcessList := ProductionService.GetProcessList('LOT-001');
|
|
CheckNotNull(ProcessList, 'Process list should be returned');
|
|
Check(ProcessList.Count >= 0, 'Process list should have at least 0 items');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingServiceValidateGoodsNo;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
Result: Boolean;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
Result := ProductionService.ValidateGoodsNo('ITEM-001', 'PROCESS-001', 'WO-001');
|
|
Check(Result, 'Validate goods no should succeed');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestProductionReportingServiceSubmitData;
|
|
var
|
|
ProductionService: TProductionReportingService;
|
|
Result: Boolean;
|
|
begin
|
|
ProductionService := TProductionReportingService.Create('test-token');
|
|
try
|
|
Result := ProductionService.SubmitProductionData('test-user', 'LOT-001', '1', 'ITEM-001');
|
|
Check(Result, 'Submit production data should succeed');
|
|
finally
|
|
ProductionService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestDeviceConfigService;
|
|
var
|
|
DeviceConfigService: TDeviceConfigService;
|
|
Result: Boolean;
|
|
begin
|
|
DeviceConfigService := TDeviceConfigService.Create;
|
|
try
|
|
Result := DeviceConfigService.LoadDeviceConfig;
|
|
Check(Result, 'Load device config should succeed');
|
|
|
|
Result := DeviceConfigService.SaveDeviceConfig;
|
|
Check(Result, 'Save device config should succeed');
|
|
finally
|
|
DeviceConfigService.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TTestBusinessServices.TestDataAccessService;
|
|
var
|
|
DataAccessService: TDataAccessService;
|
|
Value: string;
|
|
begin
|
|
DataAccessService := TDataAccessService.Create;
|
|
try
|
|
Value := DataAccessService.ReadConfigValue('Test', 'Key', 'Default');
|
|
CheckEquals('Default', Value, 'Default value should be returned');
|
|
|
|
DataAccessService.WriteConfigValue('Test', 'Key', 'Value');
|
|
Value := DataAccessService.ReadConfigValue('Test', 'Key', 'Default');
|
|
CheckEquals('Value', Value, 'Written value should be returned');
|
|
finally
|
|
DataAccessService.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TTestCommonUtils }
|
|
|
|
procedure TTestCommonUtils.TestValidator;
|
|
begin
|
|
Check(TValidator.IsEmpty(''), 'Empty string should be detected');
|
|
Check(not TValidator.IsEmpty('Test'), 'Non-empty string should not be detected as empty');
|
|
Check(TValidator.IsInteger('123'), 'Valid integer should be detected');
|
|
Check(not TValidator.IsInteger('abc'), 'Invalid integer should not be detected');
|
|
Check(TValidator.IsFloat('123.45'), 'Valid float should be detected');
|
|
Check(not TValidator.IsFloat('abc'), 'Invalid float should not be detected');
|
|
end;
|
|
|
|
procedure TTestCommonUtils.TestStringHelper;
|
|
var
|
|
S: string;
|
|
begin
|
|
S := '123';
|
|
Check(S.IsInteger, 'String should be detected as integer');
|
|
S := '123.45';
|
|
Check(S.IsFloat, 'String should be detected as float');
|
|
S := 'Hello';
|
|
Check(S.Contains('ell'), 'String should contain substring');
|
|
Check(S.StartsWith('He'), 'String should start with prefix');
|
|
Check(S.EndsWith('lo'), 'String should end with suffix');
|
|
end;
|
|
|
|
procedure TTestCommonUtils.TestDateTimeHelper;
|
|
var
|
|
DT: TDateTime;
|
|
begin
|
|
DT := Now;
|
|
Check(TDateTimeHelper.IsToday(DT), 'Date should be today');
|
|
Check(TDateTimeHelper.IsSameDay(DT, DT), 'Date should be same day');
|
|
end;
|
|
|
|
procedure TTestCommonUtils.TestFileHelper;
|
|
var
|
|
TempFile: string;
|
|
Content: string;
|
|
begin
|
|
TempFile := TFileHelper.GetTempFileName('.txt');
|
|
try
|
|
TFileHelper.WriteTextFile(TempFile, 'Test content');
|
|
Content := TFileHelper.ReadTextFile(TempFile);
|
|
CheckEquals('Test content', Content, 'File content should match');
|
|
finally
|
|
if FileExists(TempFile) then
|
|
DeleteFile(TempFile);
|
|
end;
|
|
end;
|
|
|
|
procedure TTestCommonUtils.TestJSONHelper;
|
|
var
|
|
JSON: TJSONObject;
|
|
Value: string;
|
|
IntValue: Integer;
|
|
begin
|
|
JSON := TJSONObject.Create;
|
|
try
|
|
JSON.AddPair('string', 'value');
|
|
JSON.AddPair('integer', TJSONNumber.Create(123));
|
|
|
|
Value := TJSONHelper.GetString(JSON, 'string', 'default');
|
|
CheckEquals('value', Value, 'String value should be retrieved');
|
|
|
|
IntValue := TJSONHelper.GetInteger(JSON, 'integer', 0);
|
|
CheckEquals(123, IntValue, 'Integer value should be retrieved');
|
|
finally
|
|
JSON.Free;
|
|
end;
|
|
end;
|
|
|
|
initialization
|
|
RegisterTest('ExceptionHandler', TTestExceptionHandler.Suite);
|
|
RegisterTest('LogManager', TTestLogManager.Suite);
|
|
RegisterTest('ConfigManager', TTestConfigManager.Suite);
|
|
RegisterTest('BusinessServices', TTestBusinessServices.Suite);
|
|
RegisterTest('CommonUtils', TTestCommonUtils.Suite);
|
|
|
|
end.
|