public async Task Return_CustomResponseObject_WhenCallIsFailed()
{
HttpResponseMessage httpResponseMessage = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest,
};
Example example = new Example();
HandlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(httpResponseMessage);
DilibHttpClientResponse <Example> result = await DiLibHttpClient.DeleteAsync <Example>(
AbsoluteUri, example)
.ConfigureAwait(false);
result.Should().BeOfType <DilibHttpClientResponse <Example> >();
result.IsSuccess.Should().BeFalse();
result.HttpStatusCode.Should().Be((int)HttpStatusCode.BadRequest);
result.Exception.Should().BeOfType <HttpRequestException>();
}
public async Task Return_CustomResponseObject_WhenCallIsSuccessful()
{
HttpResponseMessage httpResponseMessage = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(@"{ ""result"":""success""}"),
};
HandlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(httpResponseMessage);
DilibHttpClientResponse <ExampleResult> exampleResult = await DiLibHttpClient.GetAsync <ExampleResult>(
AbsoluteUri)
.ConfigureAwait(false);
exampleResult.Should().BeOfType <DilibHttpClientResponse <ExampleResult> >();
exampleResult.IsSuccess.Should().BeTrue();
exampleResult.HttpStatusCode.Should().Be((int)HttpStatusCode.OK);
exampleResult.Result.Should().BeOfType <ExampleResult>();
exampleResult.Result.Result.Should().Be("success");
}
public async Task TestListViewProcessSelectedItem()
{
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)),
o => o.StringArray = new[] { "a" });
await Application.TestListViewProcessSelectedItem(typeof(RestPropertyObject));
}
public async Task Request_object()
{
HandlerMock.SetupRestOperationObject(_restObjects);
var restObject = await Application.CreateObjectSpace(typeof(RestOperationObject))
.Request <RestOperationObject>();
restObject.Name.ShouldBe(_restObjects.Last().Name);
}
public void BoundValues(int value, int threshold, int callCount)
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerter();
alerter.Add(threshold, handler.AlertHandler);
alerter.Check(value);
Assert.Equal(callCount, handler.CallCount);
}
public void BoundValues(int value, int threshold, int callCount)
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { threshold });
alerter.ThresholdReached += handler.AlertHandler;
alerter.Check(value);
Assert.Equal(callCount, handler.CallCount);
}
public async Task ReadOnly_DomainComponent_Dependency()
{
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)));
var restObject = await Application.CreateObjectSpace(typeof(RestPropertyObject))
.Request <RestPropertyObject>();
restObject.RestObjectStats.ShouldNotBeNull();
restObject.RestObjectStats.Name.ShouldBe(restObject.RestOperationObjectName);
}
public async Task Arrays_BindingList()
{
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)), o => o.StringArray = new [] { "a" });
var restObject = await Application.CreateObjectSpace(typeof(RestPropertyObject))
.Request <RestPropertyObject>();
restObject.StringArrayList.Count.ShouldBe(1);
restObject.StringArrayList.First().Name.ShouldBe("a");
}
public void AlertWhenReachedThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { 10 });
alerter.ThresholdReached += handler.AlertHandler;
alerter.Check(10);
Assert.Equal(1, handler.CallCount);
Assert.Equal(10, handler.ReachedThreshold);
}
public void AlertOnceWhenPassedSeveralThresholds()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { 10, 20 });
alerter.ThresholdReached += handler.AlertHandler;
alerter.Check(30);
Assert.Equal(1, handler.CallCount);
Assert.Equal(20, handler.ReachedThreshold);
}
public async Task Create_object()
{
HandlerMock.SetupRestOperationObject(_restObjects);
var objectSpace = Application.CreateObjectSpace(typeof(RestOperationObject));
objectSpace.CreateObject <RestOperationObject>();
objectSpace.CommitChanges();
await RestService.Object.FirstAsync();
}
public void AlertWhenReachedThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerter();
alerter.Add(10, handler.AlertHandler);
alerter.Check(10);
Assert.Equal(1, handler.CallCount);
Assert.Equal(10, handler.ReachedThreshold);
}
public void NoAlertWhenNoReachedThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { 100 });
alerter.ThresholdReached += handler.AlertHandler;
alerter.Check(0);
alerter.Check(50);
alerter.Check(99);
Assert.Equal(0, handler.CallCount);
}
public async Task Delete_object()
{
var objectSpace = Application.CreateObjectSpace(typeof(RestOperationObject));
var objects = new[] { objectSpace.CreateObject <RestOperationObject>() };
HandlerMock.SetupRestOperationObject(objects);
var restObject = await objectSpace.Request <RestOperationObject>();
objectSpace.Delete(restObject);
objectSpace.CommitChanges();
await RestService.Object.FirstAsync();
}
public void AlertOnceWhenPassedSeveralThresholds()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerter();
alerter.Add(10, handler.AlertHandler);
alerter.Add(20, handler.AlertHandler);
alerter.Check(30);
Assert.Equal(1, handler.CallCount);
Assert.Equal(20, handler.ReachedThreshold);
}
public void NoAlertWhenNoReachedThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerter();
alerter.Add(100, handler.AlertHandler);
alerter.Check(0);
alerter.Check(50);
alerter.Check(99);
Assert.Equal(0, handler.CallCount);
}
public void ManyChecks()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(Enumerable.Range(0, 100).Select(i => i * 10));
alerter.ThresholdReached += handler.AlertHandler;
for (int i = 0; i < 10000; i++)
{
alerter.Check(i);
}
Assert.Equal(100, handler.CallCount);
Assert.Equal(990, handler.ReachedThreshold);
}
public void AlertOnceOnReachedThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { 10 });
alerter.ThresholdReached += handler.AlertHandler;
// Alert
alerter.Check(10);
Assert.Equal(1, handler.CallCount);
// No alert, already reached 10
alerter.Check(11);
Assert.Equal(1, handler.CallCount);
}
public void Setup()
{
Handler = new HandlerMock();
OwnerProperty = PropertyStub
.WithBehaviors(Handler)
.Build();
OwnerVM = ViewModelStub
.WithProperties(OwnerProperty)
.Build();
Command = new ViewModelCommand(OwnerVM, OwnerProperty);
}
public async Task ReactiveCollection_Fetch()
{
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)));
var restObject = await Application.CreateObjectSpace(typeof(RestPropertyObject))
.Request <RestPropertyObject>();
var whenListChanged = restObject.ActiveObjects.WhenListChanged().FirstAsync();
var activeObjectsCount = restObject.ActiveObjects.Count;
activeObjectsCount.ShouldBe(0);
await whenListChanged;
restObject.ActiveObjects.Count.ShouldBeGreaterThan(activeObjectsCount);
}
public void RestOperation_Action()
{
HandlerMock.SetupRestOperationObject(_restObjects);
var window = Application.CreateViewWindow();
var detailView = Application.NewDetailView(typeof(RestOperationObject));
window.SetView(detailView);
var action = window.Action("Act");
action.ShouldNotBeNull();
action.Active.ResultValue.ShouldBeTrue();
action.DoExecute(_ => new[] { detailView.CurrentObject });
HandlerMock.VerifySend(Times.Exactly(1), message => $"{message.RequestUri}".Contains("Act"));
}
public void ManyChecks()
{
var alerter = new ThresholdAlerter();
var handler = new HandlerMock();
for (int i = 0; i < 1000; i += 10)
{
alerter.Add(i, handler.AlertHandler);
}
for (int i = 0; i < 10000; i++)
{
alerter.Check(i);
}
Assert.Equal(100, handler.CallCount);
Assert.Equal(990, handler.ReachedThreshold);
}
public async Task Do_not_Cache_Post_Requests()
{
var objectSpace = Application.CreateObjectSpace(typeof(RestOperationObject));
var restOperationObject = objectSpace.CreateObject <RestOperationObject>();
var objects = new[] { restOperationObject };
HandlerMock.SetupRestOperationObject(objects);
var restObject = await objectSpace.Request <RestOperationObject>().Timeout(Timeout);
restObject.Name = "1";
objectSpace.CommitChanges();
restObject.Name = "2";
objectSpace.CommitChanges();
await RestService.Object.FirstAsync().Timeout(Timeout);
HandlerMock.VerifySend(Times.Exactly(2), message => $"{message.RequestUri}".Contains($"Update{nameof(RestOperationObject)}"));
}
public void AlertWhenValueGoesDownAndUpThreshold()
{
var handler = new HandlerMock();
var alerter = new ThresholdAlerterV2(new[] { 10, 20 });
alerter.ThresholdReached += handler.AlertHandler;
// Alert
alerter.Check(20);
Assert.Equal(1, handler.CallCount);
Assert.Equal(20, handler.ReachedThreshold);
// No alert
alerter.Check(0);
Assert.Equal(1, handler.CallCount);
// Alert again
alerter.Check(17);
Assert.Equal(2, handler.CallCount);
Assert.Equal(10, handler.ReachedThreshold);
}
public async Task Property_Operation_on_existing_object(bool isEnable, string name)
{
var objects = new[] { new RestOperationPropertyObject()
{
IsEnabled = !isEnable
} };
HandlerMock.SetupRestOperationObject(objects);
var objectSpace = Application.CreateObjectSpace(typeof(RestOperationPropertyObject));
var restObject = await objectSpace.Request <RestOperationPropertyObject>();
restObject.IsEnabled = isEnable;
objectSpace.CommitChanges();
await RestService.Object.FirstAsync(t =>
t.message.RequestMessage?.RequestUri is not null && t.message.RequestMessage != null &&
t.message.RequestMessage.RequestUri.AbsoluteUri.Contains(name));
}
public async Task Cache_Get_Requests(int times)
{
var typeInfo = Application.TypesInfo.FindTypeInfo(typeof(RestPropertyObject));
var operationAttribute = typeInfo.FindAttributes <RestOperationAttribute>().First(attribute => attribute.Operation == Operation.Get);
if (times == 2)
{
operationAttribute.PollInterval = 0;
}
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)));
await Application.CreateObjectSpace(typeof(RestPropertyObject))
.Request(typeof(RestPropertyObject)).FirstAsync().Timeout(Timeout);
await Application.CreateObjectSpace(typeof(RestPropertyObject))
.Request(typeof(RestPropertyObject)).Timeout(Timeout);
HandlerMock.VerifySend(Times.Exactly(times), message => $"{message.RequestUri}".Contains($"Get{nameof(RestPropertyObject)}"));
operationAttribute.PollInterval = RestOperationAttribute.DefaultPollingInterval;
}
public async Task Arrays_BindingList_Lookup_Datasource()
{
HandlerMock.SetupRestPropertyObject(Application.CreateObjectSpace(typeof(RestPropertyObject)),
o => o.StringArray = new[] { "a" });
var detailView = await Application.TestListViewProcessSelectedItem(typeof(RestPropertyObject));
var nestedFrame = detailView.GetListPropertyEditor <RestPropertyObject>(o => o.StringArrayList).Frame;
var whenDetailViewCreated =
Application.WhenDetailViewCreated(typeof(ObjectString)).FirstAsync().SubscribeReplay();
var newObjectAction = nestedFrame.GetController <NewObjectViewController>().NewObjectAction;
newObjectAction.DoExecute(
space => new[] { space.GetObject(nestedFrame.View.AsListView().CollectionSource.Objects().First()) },
true);
var t = await whenDetailViewCreated;
var currentObject = ((ObjectString)t.e.View.CurrentObject);
var restPropertyObject = ((RestPropertyObject)detailView.CurrentObject);
currentObject.DataSource.Count.ShouldBe(restPropertyObject.StringArraySource.Count);
currentObject.DataSource.Select(s => s.Name).First()
.ShouldBe(restPropertyObject.StringArraySource.Select(s => s.Name).First());
}
public override void Untyped_Response_With_Content_Register_Callback()
{
UntypedMock.Object.BadRequest((object res) => { });
HandlerMock.Verify(handler => handler.RegisterCallback(HttpStatusCode.BadRequest, It.IsAny <Action <object> >()), Times.Once);
}
public override void Typed_Response_Without_Content_Register_Callback()
{
TypedMock.Object.InternalServerError(() => { });
HandlerMock.Verify(handler => handler.RegisterCallback(HttpStatusCode.InternalServerError, It.IsAny <Action>()), Times.Once);
}
public override void Untyped_Response_Without_Content_Register_Callback()
{
UntypedMock.Object.Forbidden(() => { });
HandlerMock.Verify(handler => handler.RegisterCallback(HttpStatusCode.Forbidden, It.IsAny <Action>()), Times.Once);
}
