public void WhenCreatingContractsAlertAndAlertsHaveDifferentPredicatesThenTheCorrelationHashIsDifferent()
{
// A predicate property is different - correlation hash should be the different
ContractsAlert contractsAlert = new TestAlert().CreateContractsAlert(this.analysisRequest, SmartDetectorName, false, false);
ContractsAlert contractsAlertDifferentPredicate = new TestAlert(title: "AlertTitle2").CreateContractsAlert(this.analysisRequest, SmartDetectorName, false, false);
Assert.AreNotEqual(contractsAlert.CorrelationHash, contractsAlertDifferentPredicate.CorrelationHash);
}
public void WhenCreatingContractsAlertWithMismatchListTableThenExceptionIsThrown()
{
var alert = new TestAlert();
alert.SingleColumnTable.Add(2);
ContractsAlert contractsAlert = alert.CreateContractsAlert(AnalysisRequest, "detector", false, false);
}
public void WhenCreatingContractsAlertAndAlertsHaveIdenticalPredicatesThenTheCorrelationHashIsSame()
{
// A non predicate property is different - correlation hash should be the same
ContractsAlert contractsAlert1 = new TestAlert().CreateContractsAlert(this.analysisRequest, SmartDetectorName, false, false);
ContractsAlert contractsAlert2 = new TestAlert(rawProperty: 2).CreateContractsAlert(this.analysisRequest, SmartDetectorName, false, false);
Assert.AreEqual(contractsAlert1.CorrelationHash, contractsAlert2.CorrelationHash);
}
public async Task IsUserAuthorizedToManageAlert_DoesNotAllowUserWithoutTbServiceToManageNonTransferAlert()
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var tbService = new TBService()
{
Code = "TBS0008"
};
var testAlert = new TestAlert()
{
NotificationId = 2, AlertType = AlertType.Test
};
var testNotification = new Notification {
HospitalDetails = new HospitalDetails {
TBServiceCode = "TBS1111"
}
};
_mockUserHelper.Setup(uh => uh.UserIsReadOnly(It.IsAny <ClaimsPrincipal>())).Returns(false);
_mockUserService.Setup(us => us.GetTbServicesAsync(It.IsAny <ClaimsPrincipal>()))
.Returns(Task.FromResult((new List <TBService> {
tbService
}).AsEnumerable()));
_mockNotificationRepository.Setup(nr => nr.GetNotificationAsync((int)testAlert.NotificationId))
.Returns(Task.FromResult(testNotification));
// Act
var result = await _authorizationService.IsUserAuthorizedToManageAlert(testUser, testAlert);
// Assert
Assert.False(result);
}
void Awake()
{
m_Instance = this;
m_ScaleX = Screen.width / UIID.DEFAULT_WIDTH;
m_ScaleY = Screen.height / UIID.DEFAULT_HEIGHT;
m_Rectwindow = new Rect(0, 0, 300 * m_ScaleX, 150 * m_ScaleY);
m_TextStyle = new GUIStyle();
m_TextStyle.fontSize = (int)(20.0f * (m_ScaleX + m_ScaleY) * 0.5f);
m_TextStyle.wordWrap = true;
}
public async Task AddUniqueAlert_FailsIfNoAlertWithSameNotificationIdAndAlertType()
{
// Arrange
_mockAlertRepository.Setup(x =>
x.GetAlertByNotificationIdAndTypeAsync <TestAlert>(It.IsAny <int>()))
.Returns(Task.FromResult((TestAlert)null));
var testAlert = new TestAlert {
NotificationId = 2, AlertType = AlertType.TransferRequest
};
// Act
var result = await _alertService.AddUniqueAlertAsync(testAlert);
// Assert
Assert.True(result);
}
public async Task AddUniqueOpenAlertAsync_CreatesAlertWithCurrentTimestamp()
{
// Arrange
_mockAlertRepository.Setup(x =>
x.GetOpenAlertByNotificationId <TestAlert>(It.IsAny <int>()))
.Returns(Task.FromResult((TestAlert)null));
var testAlert = new TestAlert {
NotificationId = 2, AlertType = AlertType.TransferRequest
};
// Act
await _alertService.AddUniqueOpenAlertAsync(testAlert);
// Assert
Assert.Equal(DateTime.Now, testAlert.CreationDate, TimeSpan.FromSeconds(1));
}
public void WhenCreatingContractsAlertThenAlertDataIsCorrect()
{
var resourceId = new ResourceIdentifier(ResourceType.ApplicationInsights, "subscription", "resourceGroup", "myApp");
var alert = new TestAlert(resourceIdentifier: resourceId);
ContractsAlert contractsAlert = alert.CreateContractsAlert(this.analysisRequest, SmartDetectorName, false, false);
Assert.AreEqual("AlertTitle", contractsAlert.Title);
Assert.AreEqual("/subscriptions/subscription/resourceGroups/resourceGroup/providers/Microsoft.Insights/components/myApp", contractsAlert.ResourceId);
Assert.AreEqual(alert.OccurenceTime, contractsAlert.OccurenceTime);
Assert.AreEqual("smartDetectorId", contractsAlert.SmartDetectorId);
Assert.AreEqual(SmartDetectorName, contractsAlert.SmartDetectorName);
Assert.AreEqual((int)this.analysisRequest.Cadence.TotalMinutes, contractsAlert.AnalysisWindowSizeInMinutes);
Assert.AreEqual(SignalType.Log, contractsAlert.SignalType);
Assert.IsNull(contractsAlert.ResolutionParameters);
this.AssertAlertProperties(contractsAlert);
}
public async Task IsUserAuthorizedToManageAlert_DoesNotAllowReadOnlyUserToManageAlert()
{
// Arrange
var testUser = new ClaimsPrincipal(new ClaimsIdentity("TestDev"));
var testAlert = new TestAlert()
{
NotificationId = 2, AlertType = AlertType.Test
};
_mockUserHelper.Setup(uh => uh.UserIsReadOnly(It.IsAny <ClaimsPrincipal>())).Returns(true);
// Act
var result = await _authorizationService.IsUserAuthorizedToManageAlert(testUser, testAlert);
// Assert
Assert.False(result);
}
public async Task Send()
{
foreach (var i in Enumerable.Range(1, 20))
{
var message = new Message <string>("PlatformEvent", TestAlert.Replace("Test Alert", "Test Alert " + i + " - " + DateTime.UtcNow));
using (var bm = message.ToBrokeredMessage())
{
try
{
await Client.SendAsync(bm);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
}
public async Task AddUniqueAlert_AddsIfNoAlertWithSameNotificationIdAndAlertType()
{
// Arrange
var matchingAlert = Task.FromResult(new TestAlert {
AlertId = 2
});
var testAlert = new TestAlert {
NotificationId = 2, AlertType = AlertType.TransferRequest
};
_mockAlertRepository.Setup(x =>
x.GetAlertByNotificationIdAndTypeAsync <TestAlert>(testAlert.NotificationId.Value))
.Returns(matchingAlert);
// Act
var result = await _alertService.AddUniqueAlertAsync(testAlert);
// Assert
Assert.False(result);
}
public void WhenAlertsHaveDifferentPredicatesThenTheCorrelationHashIsDifferent()
{
var alert1 = new TestAlert();
var alert2 = new TestAlert();
alert2.NoPresentation += "X";
var contractsAlert1 = CreateContractsAlert(alert1);
// A non predicate property is different - correlation hash should be the same
var contractsAlert2 = CreateContractsAlert(alert2);
Assert.AreNotEqual(contractsAlert1.Id, contractsAlert2.Id);
Assert.AreEqual(contractsAlert1.CorrelationHash, contractsAlert2.CorrelationHash);
// A predicate property is different - correlation hash should be the different
alert2.OnlyPredicate += "X";
contractsAlert2 = CreateContractsAlert(alert2);
Assert.AreNotEqual(contractsAlert1.Id, contractsAlert2.Id);
Assert.AreNotEqual(contractsAlert1.CorrelationHash, contractsAlert2.CorrelationHash);
}
public void WhenCreatingContractsAlertAndLogAndMetricClientsWereUsedThenTheSignalTypeIsCorrect()
{
ContractsAlert contractsAlert = new TestAlert().CreateContractsAlert(this.analysisRequest, SmartDetectorName, true, true);
Assert.AreEqual(SignalType.Multiple, contractsAlert.SignalType, "Unexpected signal type");
}
public void WhenCreatingContractsAlertAndLogClientWasUsedThenTheSignalTypeIsCorrect()
{
ContractsAlert contractsAlert = new TestAlert().CreateContractsAlert(this.analysisRequest, SmartDetectorName, true, false);
Assert.AreEqual(SignalType.Log, contractsAlert.SignalType, "Unexpected signal type");
}
