public static UnitTestCacheWriteObject Create(UnitTest unitTest, Guid accountId)
{
if (unitTest == null)
{
return(null);
}
return(new UnitTestCacheWriteObject()
{
Id = unitTest.Id,
AccountId = accountId,
ErrorColor = unitTest.ErrorColor,
Enable = unitTest.Enable,
DisableComment = unitTest.DisableComment,
DisableToDate = unitTest.DisableToDate,
DisplayName = unitTest.DisplayName,
CreateDate = unitTest.CreateDate,
ComponentId = unitTest.ComponentId,
IsDeleted = unitTest.IsDeleted,
NextDate = unitTest.NextExecutionDate,
ParentEnable = unitTest.ParentEnable,
PeriodSeconds = unitTest.PeriodSeconds,
SimpleMode = unitTest.SimpleMode,
StatusDataId = unitTest.StatusDataId,
SystemName = unitTest.SystemName,
TypeId = unitTest.TypeId,
NoSignalColor = unitTest.NoSignalColor,
ActualTime = TimeSpanHelper.FromSeconds(unitTest.ActualTimeSecs),
LastExecutionDate = unitTest.LastExecutionDate
});
}
public void Load(Guid?id, Guid?componentId)
{
if (id.HasValue)
{
var test = GetUnitTest(id.Value);
CheckName = test.DisplayName;
ComponentId = test.ComponentId;
Period = TimeSpan.FromSeconds(test.PeriodSeconds ?? 0);
ActualTime = TimeSpanHelper.FromSeconds(test.ActualTimeSecs);
NoSignalColor = ColorStatusSelectorValue.FromColor(test.NoSignalColor);
ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(test.ErrorColor);
if (ErrorColor.NotChecked)
{
ErrorColor.RedChecked = true;
}
}
else
{
Period = TimeSpan.FromMinutes(10);
ActualTime = TimeSpan.FromMinutes(20);
ComponentId = componentId;
CheckName = DefaultCheckName;
ErrorColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm);
NoSignalColor = ColorStatusSelectorValue.FromUnitTestResultStatus(UnitTestResult.Alarm);
}
}
public IMetricCacheReadObject CreateMetric(Guid accountId, CreateMetricRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var meticType = GetOrCreateType(accountId, data.MetricName);
var metricId = CreateMetric(accountId, data.ComponentId, meticType.Id);
var cache = new AccountCache(accountId);
using (var metric = cache.Metrics.Write(metricId))
{
metric.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
metric.NoSignalColor = data.NoSignalColor;
metric.ConditionRed = data.AlarmCondition;
metric.ConditionYellow = data.WarningCondition;
metric.ConditionGreen = data.SuccessCondition;
metric.ElseColor = data.ElseColor;
metric.BeginSave();
}
var metrikRead = cache.Metrics.Read(metricId);
metrikRead.WaitSaveChanges();
return(metrikRead);
}
public ActionResult Edit(Guid?id, Guid?componentId, Guid?metricTypeId)
{
var model = new EditModel()
{
ComponentId = componentId,
MetricTypeId = metricTypeId
};
if (id.HasValue)
{
var metric = GetMetricById(id.Value);
if (metric != null)
{
model.Metric = metric;
model.MetricType = metric.MetricType;
model.Id = metric.Id;
model.ComponentId = metric.ComponentId;
model.MetricTypeId = metric.MetricTypeId;
model.ConditionRed = metric.ConditionAlarm;
model.ConditionYellow = metric.ConditionWarning;
model.ConditionGreen = metric.ConditionSuccess;
model.ElseColor = ColorStatusSelectorValue.FromColor(metric.ConditionElseColor);
model.ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs);
}
}
return(View(model));
}
public IMetricTypeCacheReadObject CreateMetricType(Guid accountId, CreateMetricTypeRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (string.IsNullOrWhiteSpace(data.SystemName))
{
throw new UserFriendlyException("Не укзан SystemName");
}
if (string.IsNullOrWhiteSpace(data.DisplayName))
{
data.DisplayName = data.SystemName;
}
var metricTypeId = AllCaches.MetricTypes.CreateMetricType(accountId, data.SystemName);
var cache = new AccountCache(accountId);
using (var metricType = cache.MetricTypes.Write(metricTypeId))
{
metricType.DisplayName = data.DisplayName;
metricType.ConditionRed = data.AlarmCondition;
metricType.ConditionYellow = data.WarningCondition;
metricType.ConditionGreen = data.SuccessCondition;
metricType.ElseColor = data.ElseColor;
metricType.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
metricType.NoSignalColor = data.NoSignalColor;
metricType.BeginSave();
metricType.WaitSaveChanges();
return(metricType);
}
}
/// <summary>
/// Редактирует подписку
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(Guid id)
{
var subscriptionRepository = CurrentAccountDbContext.GetSubscriptionRepository();
var subscription = subscriptionRepository.GetById(id);
var model = new SubscriptionEditModel()
{
ModalMode = Request.IsAjaxRequest(),
ReturnUrl = Url.Action("Index", new { userId = subscription.UserId }),
Id = subscription.Id,
Object = subscription.Object,
NotifyBetterStatus = subscription.NotifyBetterStatus,
UserId = subscription.UserId,
ComponentTypeId = subscription.ComponentTypeId,
ComponentId = subscription.ComponentId,
Channel = subscription.Channel,
CanShowChannel = false,
CanShowComponentType = false,
CanShowComponent = false,
IsEnabled = subscription.IsEnabled,
Color = ColorStatusSelectorValue.FromEventImportance(subscription.Importance),
MinimumDuration = TimeSpanHelper.FromSeconds(subscription.DurationMinimumInSeconds),
ResendTime = TimeSpanHelper.FromSeconds(subscription.ResendTimeInSeconds)
};
return(View(model));
}
public static MetricCacheWriteObject Create(Metric metric, Guid accountId)
{
if (metric == null)
{
return(null);
}
var cache = new MetricCacheWriteObject()
{
Id = metric.Id,
Enable = metric.Enable,
DisableToDate = metric.DisableToDate,
DisableComment = metric.DisableComment,
StatusDataId = metric.StatusDataId,
Value = metric.Value,
ParentEnable = metric.ParentEnable,
ComponentId = metric.ComponentId,
AccountId = accountId,
BeginDate = metric.BeginDate,
ActualDate = metric.ActualDate,
IsDeleted = metric.IsDeleted,
CreateDate = metric.CreateDate,
MetricTypeId = metric.MetricTypeId,
ActualTime = TimeSpanHelper.FromSeconds(metric.ActualTimeSecs),
ConditionRed = metric.ConditionAlarm,
ConditionYellow = metric.ConditionWarning,
ConditionGreen = metric.ConditionSuccess,
ElseColor = metric.ConditionElseColor,
NoSignalColor = metric.NoSignalColor
};
return(cache);
}
public ActionResult Edit(Guid?id)
{
var model = new EditModel()
{
ModalMode = Request.IsAjaxRequest()
};
if (id.HasValue)
{
var metricType = GetMetricTypeById(id.Value);
model.Id = metricType.Id;
model.SystemName = metricType.SystemName;
model.DisplayName = metricType.DisplayName;
model.NoSignalColor = ColorStatusSelectorValue.FromColor(metricType.NoSignalColor);
model.ActualTime = TimeSpanHelper.FromSeconds(metricType.ActualTimeSecs);
model.ConditionRed = metricType.ConditionAlarm;
model.ConditionYellow = metricType.ConditionWarning;
model.ConditionGreen = metricType.ConditionSuccess;
model.ElseColor = ColorStatusSelectorValue.FromColor(metricType.ConditionElseColor);
}
else
{
// значения по умолчанию
model.NoSignalColor = new ColorStatusSelectorValue()
{
RedChecked = true
};
model.ElseColor = new ColorStatusSelectorValue()
{
RedChecked = true
};
}
return(View(model));
}
protected Event CreateUnitTestResultEvent(
IUnitTestCacheReadObject unitTest,
SendUnitTestResultRequestData data,
DateTime processDate)
{
data.Message = data.Message ?? string.Empty;
if (data.Message.Length > 255)
{
data.Message = data.Message.Substring(0, 255);
}
var importance = EventImportanceHelper.Get(data.Result ?? UnitTestResult.Unknown);
var cache = new AccountCache(unitTest.AccountId);
var unittestType = cache.UnitTestTypes.Read(unitTest.TypeId);
var actualInterval = unitTest.ActualTime // сначала берем из настроек проверки в ЛК
?? TimeSpanHelper.FromSeconds(unittestType.ActualTimeSecs) // потом из настроек типа проверки в ЛК
?? TimeSpanHelper.FromSeconds(data.ActualIntervalSeconds) // потом из сообщения
?? TimeSpan.FromMinutes(5); // по умолчанию 5 мин
var actualDate = processDate + actualInterval;
var joinKeyHash = data.ReasonCode ?? 0;
var result = new Event()
{
Id = Guid.NewGuid(),
Count = 1,
JoinKeyHash = joinKeyHash,
Importance = importance,
OwnerId = unitTest.Id,
ActualDate = actualDate,
CreateDate = DateTime.Now,
LastUpdateDate = processDate,
StartDate = processDate,
EndDate = processDate,
Message = data.Message,
EventTypeId = SystemEventType.UnitTestResult.Id,
Category = EventCategory.UnitTestResult
};
if (data.Properties != null)
{
result.Properties = ApiConverter.GetEventProperties(data.Properties);
}
return(result);
}
public void UpdateMetric(Guid accountId, UpdateMetricRequestData data)
{
var cache = new AccountCache(accountId);
using (var metric = cache.Metrics.Write(data.MetricId))
{
metric.ConditionRed = data.AlarmCondition;
metric.ConditionYellow = data.WarningCondition;
metric.ConditionGreen = data.SuccessCondition;
metric.ElseColor = data.ElseColor;
metric.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
metric.NoSignalColor = data.NoSignalColor;
metric.BeginSave();
}
cache.Metrics.Read(data.MetricId).WaitSaveChanges();
}
public void EventTypeEditTest()
{
var account = TestHelper.GetTestAccount();
var user = TestHelper.GetAccountAdminUser(account.Id);
var eventType = TestHelper.GetTestEventType(account.Id);
EventTypeEditModel model;
using (var controller = new EventTypesController(account.Id, user.Id))
{
var result = (ViewResultBase)controller.Edit(eventType.Id);
model = (EventTypeEditModel)result.Model;
Assert.Equal(eventType.Id, model.Id);
Assert.Equal(eventType.DisplayName, model.DisplayName);
Assert.Equal(eventType.SystemName, model.SystemName);
Assert.Equal(eventType.Category, model.Category);
Assert.Equal(TimeSpanHelper.FromSeconds(eventType.JoinIntervalSeconds), model.JoinInterval);
Assert.Equal(eventType.OldVersion, model.OldVersion);
Assert.Equal(eventType.ImportanceForOld, model.ImportanceForOld);
Assert.Equal(eventType.ImportanceForNew, model.ImportanceForNew);
Assert.Equal(eventType.IsSystem, model.IsSystem);
}
model.DisplayName += "New";
model.SystemName += "New";
model.Category = EventCategory.ComponentEvent;
model.JoinInterval = TimeSpanHelper.FromSeconds(10);
model.OldVersion = "2.0.0.0";
model.ImportanceForOld = EventImportance.Alarm;
model.ImportanceForNew = EventImportance.Warning;
using (var controller = new EventTypesController(account.Id, user.Id))
{
controller.Edit(model);
}
var accountContext = AccountDbContext.CreateFromAccountId(account.Id);
var eventTypeRepository = accountContext.GetEventTypeRepository();
eventType = eventTypeRepository.GetById(model.Id);
Assert.Equal(model.Id, eventType.Id);
Assert.Equal(model.DisplayName, eventType.DisplayName);
Assert.Equal(model.SystemName, eventType.SystemName);
Assert.Equal(model.Category, eventType.Category);
Assert.Equal(model.JoinInterval, TimeSpanHelper.FromSeconds(eventType.JoinIntervalSeconds));
Assert.Equal(model.OldVersion, eventType.OldVersion);
Assert.Equal(model.ImportanceForOld, eventType.ImportanceForOld);
Assert.Equal(model.ImportanceForNew, eventType.ImportanceForNew);
Assert.Equal(model.IsSystem, eventType.IsSystem);
}
public ActionResult Show(Guid id)
{
var repository = CurrentAccountDbContext.GetUnitTestTypeRepository();
var unitTestType = repository.GetById(id);
var model = new UnitTestTypeEditModel()
{
Id = unitTestType.Id,
DisplayName = unitTestType.DisplayName,
SystemName = unitTestType.SystemName,
ActualTime = TimeSpanHelper.FromSeconds(unitTestType.ActualTimeSecs),
NoSignalColor = ColorStatusSelectorValue.FromColor(unitTestType.NoSignalColor),
IsDeleted = unitTestType.IsDeleted,
IsSystem = unitTestType.IsSystem
};
return(View(model));
}
public ActionResult Show(Guid id)
{
var metricType = GetMetricTypeById(id);
var model = new ShowModel()
{
Id = metricType.Id,
SystemName = metricType.SystemName,
DisplayName = metricType.DisplayName,
ActualTime = TimeSpanHelper.FromSeconds(metricType.ActualTimeSecs),
NoSignalColor = metricType.NoSignalColor,
ConditionRed = metricType.ConditionAlarm ?? "не задано",
ConditionYellow = metricType.ConditionWarning ?? "не задано",
ConditionGreen = metricType.ConditionSuccess ?? "не задано",
ElseColor = metricType.ConditionElseColor,
ModalMode = Request.IsAjaxRequest()
};
return(View(model));
}
public ActionResult Edit(Guid id)
{
var unitTest = GetUnitTestById(id);
var model = new UnitTestEditModel()
{
Id = unitTest.Id,
ComponentId = unitTest.Component.Id,
Date = unitTest.Bulb.EndDate,
DisplayName = unitTest.DisplayName,
IsDeleted = unitTest.IsDeleted,
Message = unitTest.Bulb.Message,
PeriodSeconds = unitTest.PeriodSeconds,
ActualTime = TimeSpanHelper.FromSeconds(unitTest.ActualTimeSecs),
NoSignalColor = ColorStatusSelectorValue.FromColor(unitTest.NoSignalColor),
Status = unitTest.Bulb.Status,
UnitTestType = unitTest.Type,
UnitTest = unitTest
};
return(View(model));
}
public void EventTypeAddTest()
{
var account = TestHelper.GetTestAccount();
var user = TestHelper.GetAccountAdminUser(account.Id);
EventTypeEditModel model;
using (var controller = new EventTypesController(account.Id, user.Id))
{
var result = (ViewResultBase)controller.Add();
model = (EventTypeEditModel)result.Model;
}
model.DisplayName = "New test event type " + Guid.NewGuid();
model.SystemName += model.DisplayName;
model.Category = EventCategory.ComponentEvent;
model.ImportanceForNew = EventImportance.Success;
model.JoinInterval = TimeSpan.FromSeconds(10);
model.OldVersion = "1.0.0.0";
model.ImportanceForOld = EventImportance.Alarm;
model.ImportanceForNew = EventImportance.Warning;
using (var controller = new EventTypesController(account.Id, user.Id))
{
controller.Add(model);
}
var accountContext = AccountDbContext.CreateFromAccountId(account.Id);
var eventTypeRepository = accountContext.GetEventTypeRepository();
var eventType = eventTypeRepository.GetOneOrNullBySystemName(model.SystemName);
Assert.NotNull(eventType);
Assert.Equal(model.DisplayName, eventType.DisplayName);
Assert.Equal(model.SystemName, eventType.SystemName);
Assert.Equal(model.Category, eventType.Category);
Assert.Equal(model.JoinInterval, TimeSpanHelper.FromSeconds(eventType.JoinIntervalSeconds));
Assert.Equal(model.OldVersion, eventType.OldVersion);
Assert.Equal(model.ImportanceForOld, eventType.ImportanceForOld);
Assert.Equal(model.ImportanceForNew, eventType.ImportanceForNew);
Assert.Equal(model.IsSystem, eventType.IsSystem);
}
public static MetricTypeCacheWriteObject Create(MetricType metricType, Guid accountId)
{
if (metricType == null)
{
return(null);
}
var cache = new MetricTypeCacheWriteObject()
{
AccountId = accountId,
Id = metricType.Id,
IsDeleted = metricType.IsDeleted,
CreateDate = metricType.CreateDate,
SystemName = metricType.SystemName,
DisplayName = metricType.DisplayName,
NoSignalColor = metricType.NoSignalColor,
ActualTime = TimeSpanHelper.FromSeconds(metricType.ActualTimeSecs),
ConditionRed = metricType.ConditionAlarm,
ConditionYellow = metricType.ConditionWarning,
ConditionGreen = metricType.ConditionSuccess,
ElseColor = metricType.ConditionElseColor
};
return(cache);
}
public IMetricCacheReadObject SaveMetric(Guid accountId, SendMetricRequestData data)
{
if (data.Value.HasValue && (double.IsNaN(data.Value.Value) || double.IsInfinity(data.Value.Value)))
{
throw new ParameterErrorException("Metric value can't be Nan or Infinity");
}
var processDate = DateTime.Now;
var accountDbContext = Context.GetAccountDbContext(accountId);
// Проверим лимиты
var limitChecker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
limitChecker.CheckMetricsRequestsPerDay(accountDbContext);
// Проверим лимит размера хранилища
var size = data.GetSize();
limitChecker.CheckStorageSize(accountDbContext, size);
// получим тип метрики
var metricType = GetOrCreateType(accountId, data.Name);
// получим метрику
var componentId = data.ComponentId.Value;
var metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
var createMetricLock = LockObject.ForComponent(componentId);
lock (createMetricLock)
{
metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
CreateMetric(accountId, componentId, metricType.Id);
metricInfo = FindMetric(accountId, componentId, metricType.Id);
if (metricInfo == null)
{
throw new Exception("Не удалось создать метрику");
}
}
}
}
using (var metric = AllCaches.Metrics.Write(metricInfo))
{
GetActualMetricInternal(metric, processDate);
// если метрика выключена
if (metric.CanProcess == false)
{
throw new ResponseCodeException(Zidium.Api.ResponseCode.ObjectDisabled, "Метрика выключена");
}
// Рассчитаем цвет
ObjectColor color;
string errorMessage = null;
try
{
color = GetColor(metricType, metric, data.Value);
}
catch (Exception exception)
{
color = ObjectColor.Red;
errorMessage = "Ошибка вычисления цвета метрики:" + exception.Message;
}
// Запишем метрику в хранилище
var status = MonitoringStatusHelper.Get(color);
// Время актуальности
var actualTime =
metric.ActualTime
?? metricType.ActualTime
?? TimeSpanHelper.FromSeconds(data.ActualIntervalSecs)
?? TimeSpan.FromHours(1);
var actualDate = processDate + actualTime;
var statusData = SetMetricValue(metricType, metric, data.Value, processDate, actualDate, status, errorMessage, true);
limitChecker.AddMetricsRequestsPerDay(accountDbContext);
limitChecker.AddMetricsSizePerDay(accountDbContext, size);
metric.BeginSave();
return(metric);
}
}
public IUnitTestCacheReadObject GetOrCreateUnitTest(Guid accountId, GetOrCreateUnitTestRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (string.IsNullOrEmpty(data.SystemName))
{
throw new ParameterRequiredException("SystemName");
}
if (data.ComponentId == null)
{
throw new ParameterRequiredException("ComponentId");
}
if (data.UnitTestTypeId == null)
{
throw new ParameterRequiredException("UnitTestTypeId");
}
var cache = new AccountCache(accountId);
var componentId = data.ComponentId.Value;
var systemName = data.SystemName;
// проверим, что тип проверки существует
var unitTestTypeId = data.UnitTestTypeId.Value;
if (!SystemUnitTestTypes.IsSystem(unitTestTypeId))
{
var unitTestType = AllCaches.UnitTestTypes.Find(new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = unitTestTypeId
});
if (unitTestType == null)
{
throw new UnknownUnitTestTypeIdException(unitTestTypeId);
}
}
// получим компонент
var component = cache.Components.Read(componentId);
if (component == null)
{
throw new UnknownComponentIdException(componentId, accountId);
}
// проверим есть ли у него ссылка на проверку
var unitTestRef = component.UnitTests.FindByName(data.SystemName);
if (unitTestRef != null)
{
// ссылка есть, вернем существующую проверку
var unitTest = cache.UnitTests.Read(unitTestRef.Id);
if (unitTest == null)
{
throw new Exception("unitTest == null");
}
return(unitTest);
}
// ссылки нет
using (var writeComponent = cache.Components.Write(componentId))
{
// проверим ссылку еще раз
unitTestRef = writeComponent.UnitTests.FindByName(data.SystemName);
if (unitTestRef != null)
{
var unitTest = cache.UnitTests.Read(unitTestRef.Id);
if (unitTest == null)
{
throw new Exception("unitTest == null");
}
return(unitTest);
}
// создадим проверку
var accountDbContext = Context.GetAccountDbContext(accountId);
// Проверим лимиты
var checker = AccountLimitsCheckerManager.GetCheckerForAccount(accountId);
var checkResult = checker.CheckMaxUnitTestsCount(accountDbContext);
if (!checkResult.Success)
{
throw new OverLimitException(checkResult.Message);
}
// проверка лимитов пройдена
if (string.IsNullOrWhiteSpace(data.DisplayName))
{
data.DisplayName = data.SystemName;
}
// создаем юнит-тест
var unitTestObj = Create(accountId, componentId, unitTestTypeId, systemName, data.DisplayName, data.NewId);
unitTestRef = new CacheObjectReference(unitTestObj.Id, unitTestObj.SystemName);
writeComponent.WriteUnitTests.Add(unitTestRef);
writeComponent.BeginSave();
checker.RefreshApiChecksCount();
// обновим свойства
using (var unitTestCache = cache.UnitTests.Write(unitTestObj.Id))
{
unitTestCache.NoSignalColor = data.NoSignalColor;
unitTestCache.ErrorColor = data.ErrorColor;
unitTestCache.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTimeSecs);
if (data.PeriodSeconds.HasValue)
{
unitTestCache.PeriodSeconds = data.PeriodSeconds;
}
if (data.SimpleMode.HasValue)
{
unitTestCache.SimpleMode = data.SimpleMode.Value;
}
unitTestCache.BeginSave();
unitTestCache.WaitSaveChanges();
return(unitTestCache);
}
}
}
public void HttpRequestUnitTestAddTest()
{
var account = TestHelper.GetTestAccount();
var user = TestHelper.GetAccountAdminUser(account.Id);
var component = account.CreateRandomComponentControl();
// Добавим новый юнит-тест
EditModel model;
using (var controller = new HttpRequestCheckController(account.Id, user.Id))
{
var result = (ViewResultBase)controller.Edit(null, component.Info.Id);
model = (EditModel)result.Model;
}
Assert.Equal(component.Info.Id, model.ComponentId);
model.CheckName = "Test_" + Guid.NewGuid();
model.Method = HttpRequestMethod.Get;
model.ResponseCode = 200;
model.Url = "http://recursion.ru";
using (var controller = new HttpRequestCheckController(account.Id, user.Id))
{
controller.Edit(model);
}
account.SaveAllCaches();
// Проверим данные созданного юнит-теста
Guid unittestId;
using (var accountContext = AccountDbContext.CreateFromAccountId(account.Id))
{
var repository = accountContext.GetUnitTestRepository();
var unitTest = repository.QueryAll().SingleOrDefault(t => t.DisplayName == model.CheckName);
Assert.NotNull(unitTest);
Assert.Equal(SystemUnitTestTypes.HttpUnitTestType.Id, unitTest.TypeId);
Assert.Equal(model.ComponentId, unitTest.ComponentId);
Assert.Equal(model.CheckName, unitTest.DisplayName);
Assert.Equal(model.Period, TimeSpanHelper.FromSeconds(unitTest.PeriodSeconds));
Assert.Equal(ObjectColor.Gray, unitTest.NoSignalColor);
var httpUnitTest = unitTest.HttpRequestUnitTest;
Assert.NotNull(httpUnitTest);
var rule = unitTest.HttpRequestUnitTest.Rules.Single();
Assert.NotNull(rule);
Assert.NotNull(rule.Url);
unittestId = unitTest.Id;
}
// 1-ый запуск проверок
// проверим, что агент НЕ будет выполнять проверку постоянно (был такой дефект, как будто период равен нулю)
var processor = new HttpRequestsProcessor(LogManager.GetCurrentClassLogger(), new CancellationToken());
processor.ProcessAccount(account.Id, unittestId);
Assert.Equal(0, processor.ErrorCount);
Assert.Equal(1, processor.SuccessCount);
account.SaveAllCaches();
// 2-ый запуск проверок
processor = new HttpRequestsProcessor(LogManager.GetCurrentClassLogger(), new CancellationToken());
processor.ProcessAccount(account.Id, unittestId);
// проверка уже выполнена, время следующего выполнения еще НЕ настало
Assert.Equal(0, processor.ErrorCount);
Assert.Equal(0, processor.SuccessCount);
}
public void UpdateUnitTest(Guid accountId, UpdateUnitTestRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (data.UnitTestId == null)
{
throw new ParameterRequiredException("UnitTestId");
}
if (data.ComponentId == null)
{
throw new ParameterRequiredException("ComponentId");
}
if (data.UnitTestId == Guid.Empty)
{
throw new ParameterErrorException("UnitTestId не может быть Guid.Empty");
}
if (data.DisplayName == null)
{
throw new ParameterRequiredException("DisplayName");
}
if (string.IsNullOrWhiteSpace(data.DisplayName))
{
throw new ParameterErrorException("DisplayName не может быть пустым");
}
//if (data.ErrorColor == null)
//{
// throw new ParameterRequiredException("ErrorColor");
//}
// SystemName сейчас не настраивается через GUI
//if (data.SystemName == null)
//{
// throw new ParameterRequiredException("SystemName");
//}
//получим компонент, чтобы убедится, что он принадлежит аккаунту
var req = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = data.ComponentId.Value
};
var component = AllCaches.Components.Find(req);
if (component == null)
{
throw new UnknownComponentIdException(data.ComponentId.Value, accountId);
}
var request = new AccountCacheRequest()
{
AccountId = accountId,
ObjectId = data.UnitTestId.Value
};
// сохраним изменения
IUnitTestCacheReadObject unitTestCache = null;
using (var unitTest = AllCaches.UnitTests.Write(request))
{
unitTestCache = unitTest;
// период выполнения проверки
if (unitTest.IsSystemType)
{
// не для всех системных проверок можно указывать период (для проверки домена нельзя)
if (SystemUnitTestTypes.CanEditPeriod(unitTest.TypeId))
{
if (data.PeriodSeconds == null)
{
throw new ParameterRequiredException("Period");
}
if (data.PeriodSeconds.Value < 60)
{
throw new ParameterErrorException("Период проверки НЕ может быть меньше 1 минуты");
}
unitTest.PeriodSeconds = (int)data.PeriodSeconds.Value;
}
// чтобы выполнить проверку прямо сейчас с новыми параметрами и увидеть результат
unitTest.NextDate = DateTime.Now;
}
unitTest.DisplayName = data.DisplayName;
unitTest.ComponentId = data.ComponentId.Value;
unitTest.ErrorColor = data.ErrorColor;
unitTest.NoSignalColor = data.NoSignalColor;
unitTest.ActualTime = TimeSpanHelper.FromSeconds(data.ActualTime);
if (data.SimpleMode.HasValue)
{
unitTest.SimpleMode = data.SimpleMode.Value;
}
unitTest.BeginSave();
}
// ждем сохранения в кэше
unitTestCache.WaitSaveChanges();
}
