public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected()
{
// Arrange
var observer = new Observer();
var model = new SomeModel(observer);
Action<int> onChange = model.Change;
var weakOnChange = new WeakReference(onChange);
var counter = Reactive.Of(0);
counter.PropertyChanged +=
(sender, args) =>
{
var handler = weakOnChange.Target as Action<int>;
if (handler != null)
handler(counter);
};
// Act
onChange = null;
GC.Collect();
counter.Value = 1;
// Assert
observer.ChangedObserved.Should().BeFalse();
}
public void CanSerializeViaInputOutputAPI()
{
using var ms = new MemoryStream();
IProtoOutput <Stream> output = RuntimeTypeModel.Default;
var orig = new SomeModel {
Id = 42
};
output.Serialize(ms, orig);
ms.Position = 0;
IProtoInput <Stream> input = RuntimeTypeModel.Default;
var clone = input.Deserialize <SomeModel>(ms);
Assert.NotSame(orig, clone);
Assert.Equal(42, clone.Id);
IProtoInput <byte[]> arrayInput = RuntimeTypeModel.Default;
clone = arrayInput.Deserialize <SomeModel>(ms.ToArray());
Assert.NotSame(orig, clone);
Assert.Equal(42, clone.Id);
var segment = new ArraySegment <byte>(ms.GetBuffer(), 0, (int)ms.Length);
IProtoInput <ArraySegment <byte> > segmentInput = RuntimeTypeModel.Default;
clone = segmentInput.Deserialize <SomeModel>(segment);
Assert.NotSame(orig, clone);
Assert.Equal(42, clone.Id);
}
public void Should_Process_Reference_Property()
{
Specification <object> specification = s => s;
var command = new MemberCommand <SomeModel, object>(m => m.SomeReferenceProperty, specification);
var blockBuilder = command.GetScopeBuilder();
var buildingContext = Substitute.For <IScopeBuilderContext>();
buildingContext.GetOrRegisterSpecificationScope(Arg.Any <Specification <object> >()).Returns(666);
var block = blockBuilder.Build(buildingContext);
block.Should().BeOfType <MemberCommandScope <SomeModel, object> >();
var modelBlock = (MemberCommandScope <SomeModel, object>)block;
modelBlock.Path = "SomeReferenceProperty";
modelBlock.GetMemberValue.Should().BeOfType <Func <SomeModel, object> >();
var someModel = new SomeModel()
{
SomeReferenceProperty = new object()
};
var memberValue = modelBlock.GetMemberValue(someModel);
memberValue.Should().BeSameAs(someModel.SomeReferenceProperty);
}
public void Should_Process_ValueType_Variable()
{
Specification <int> specification = s => s;
var command = new MemberCommand <SomeModel, int>(m => m.SomeValueVariable, specification);
var blockBuilder = command.GetScopeBuilder();
var buildingContext = Substitute.For <IScopeBuilderContext>();
buildingContext.GetOrRegisterSpecificationScope(Arg.Any <Specification <int> >()).Returns(666);
var block = blockBuilder.Build(buildingContext);
block.Should().BeOfType <MemberCommandScope <SomeModel, int> >();
var modelBlock = (MemberCommandScope <SomeModel, int>)block;
modelBlock.Path = "SomeValueVariable";
modelBlock.GetMemberValue.Should().BeOfType <Func <SomeModel, int> >();
var someModel = new SomeModel()
{
SomeValueVariable = 777
};
var memberValue = modelBlock.GetMemberValue(someModel);
memberValue.Should().Be(777);
}
protected override async Task <IResponse <T> > MakeRequest <T>(string url, HttpMethod httpMethod, HttpContent content = null, string accessToken = null,
string mediaType = "application/json", CancellationToken token = default(CancellationToken),
HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead, Dictionary <string, string> requestHeaders = null,
string defaultScheme = "Bearer")
{
if (url.Contains("google"))
{
return(await base.MakeRequest <T>(url, httpMethod, content, accessToken, mediaType, token,
completionOption, requestHeaders, defaultScheme));
}
object result;
if (typeof(T) != typeof(Stream) && !typeof(T).IsSubclassOf(typeof(Stream)))
{
var data = new SomeModel()
{
Data = "SomeData"
};
result = data;
}
else
{
var data = new MemoryStream();
await data.WriteAsync(new byte[] { 1, 2, 3, 4, 5, 6 }, 0, 6, token);
result = (T)(object)data;
}
return(new Response <T>(true)
{
Content = (T)result
});
}
public AppDetailViewModel CreateInstance(this SomeModel model)
{
var viewModel = new AppDetailViewModel();
// here you create viewmodel object from model with logic
return(viewModel);
}
private static SomeModel CreateModel()
{
var model = new SomeModel()
{
Id = -5,
Name = "didii",
Sub = new SubModel()
{
Id = 0,
Name = "",
Type = SubModelType.Allowed
},
DoubleLeft = new DoubleModel()
{
Name = "A name",
Type = DoubleModelType.In
},
DoubleRight = new DoubleModel()
{
Name = "Another name",
Type = DoubleModelType.In
}
};
Console.WriteLine("Using the following model:");
Console.WriteLine(JsonConvert.SerializeObject(model, new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
Converters = { new StringEnumConverter() }
}));
return(model);
}
public void DisplayHelpers_FindsModel_WhenViewDataIsNotSet()
{
// Arrange
var expected = $"<div class=\"HtmlEncode[[display-label]]\">HtmlEncode[[SomeProperty]]</div>{Environment.NewLine}" +
$"<div class=\"HtmlEncode[[display-field]]\">HtmlEncode[[PropValue]]</div>{Environment.NewLine}";
var model = new SomeModel
{
SomeProperty = "PropValue"
};
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
// Act
var displayResult = helper.Display(expression: string.Empty);
var displayNullResult = helper.Display(expression: null); // null is another alias for current model
var displayForResult = helper.DisplayFor(m => m);
var displayForModelResult = helper.DisplayForModel();
// Assert
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(displayResult));
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(displayNullResult));
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(displayForResult));
Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(displayForModelResult));
}
public void Display_UsesAdditionalViewData()
{
// Arrange
var model = new SomeModel {
SomeProperty = "ModelValue"
};
var view = new Mock <IView>();
view.Setup(v => v.RenderAsync(It.IsAny <ViewContext>()))
.Callback((ViewContext v) => v.Writer.WriteAsync(v.ViewData["SomeProperty"].ToString()))
.Returns(Task.FromResult(0));
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.Found("SomeView", view.Object));
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
// Act
var displayResult = helper.Display(expression: "SomeProperty", additionalViewData: new { SomeProperty = "ViewDataValue" });
// Assert
Assert.Equal("ViewDataValue", HtmlContentUtilities.HtmlContentToString(displayResult));
}
public void DisplayForModel_UsesTemplateNameAndHtmlFieldName()
{
// Arrange
var model = new SomeModel {
SomeProperty = "ModelValue"
};
var view = new Mock <IView>();
view.Setup(v => v.RenderAsync(It.IsAny <ViewContext>()))
.Callback((ViewContext v) => v.Writer.WriteAsync(v.ViewData.TemplateInfo.HtmlFieldPrefix))
.Returns(Task.FromResult(0));
var viewEngine = new Mock <ICompositeViewEngine>(MockBehavior.Strict);
viewEngine
.Setup(v => v.GetView(/*executingFilePath*/ null, It.IsAny <string>(), /*isMainPage*/ false))
.Returns(ViewEngineResult.NotFound(string.Empty, Enumerable.Empty <string>()));
viewEngine
.Setup(v => v.FindView(It.IsAny <ActionContext>(), "DisplayTemplates/SomeTemplate", /*isMainPage*/ false))
.Returns(ViewEngineResult.Found("SomeView", view.Object));
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model, viewEngine.Object);
// Act
var displayResult = helper.DisplayForModel(
templateName: "SomeTemplate",
htmlFieldName: "SomeField");
// Assert
Assert.Equal("SomeField", HtmlContentUtilities.HtmlContentToString(displayResult));
}
public string TellMeYourVersionsAndDependencyVersions()
{
return
(typeof(Class1).Assembly.GetName().Version + "\n\n" +
"My reference to Domain\n=================\n " + SomeModel.TellMeYourVersionsAndDependencyVersions() + "\n\n" +
"My reference to Common\n=================\n " + SomeUtility.TellMeYourVersion());
}
public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected()
{
// Arrange
var observer = new Observer();
var model = new SomeModel(observer);
Action <int> onChange = model.Change;
var weakOnChange = new WeakReference(onChange);
var counter = Reactive.Of(0);
counter.PropertyChanged +=
(sender, args) =>
{
var handler = weakOnChange.Target as Action <int>;
if (handler != null)
{
handler(counter);
}
};
// Act
onChange = null;
GC.Collect();
counter.Value = 1;
// Assert
observer.ChangedObserved.Should().BeFalse();
}
public IActionResult RepresentP()
{
SomeModel x = new SomeModel();
x.Text = "AnotherName";
return(View(x));
}
public ActionResult Index(SomeModel model)
{
if (ModelState.IsValid)
{
return(View(model));
}
return(View(model));
}
public TimeLevel(Level level, MonoBehaviour behaviour) : base(level)
{
timeLevel = new SomeModel <float>(level.CountWin);
timeLevel.count
.ObserveEveryValueChanged(x => x.Value).Where(x => x <= 0)
.Subscribe(xs => {
LevelFinal();
}).AddTo(behaviour);
}
public ActionResult SomeAction(SomeModel model)
{
if (ModelState.IsValid)
{
// Add to database, or whatever, and now redirect
return(RedirectToAction("Success"));
}
// Redisplay the form if validation failed.
return(View(model));
}
public IActionResult Index72()
{
SomeModel model = new SomeModel {
Text = "some text"
};
return(View(model));
//https://localhost:44395/Some/Index : some text
}
public IActionResult Index()
{
SomeModel model = new SomeModel {
Text = "display text"
};
return(View("Display", model));
//https://localhost:44395/Some/Index : display text
}
public async Task UpdateAsync(SomeModel model, CancellationToken token)
{
var existingSomeModel = await _dbContext.SomeModels.FindAsync(new object[] { model.Id }, token);
if (existingSomeModel != null)
{
model.TimeStamp = DateTime.Now;
_dbContext.Entry(existingSomeModel).CurrentValues.SetValues(model);
}
}
public IActionResult ActionWithSomeInputAndAModel(int id)
{
var model = new SomeModel
{
SelectedId = id,
Title = "This title was set in HomeController!"
};
return(View(model));
}
public IActionResult PostResume([FromBody] SomeModel model)
{
var filePath = Path.GetTempFileName();
using (var stream = new FileStream(filePath, FileMode.Create))
{
model.Resume.CopyToAsync(stream);
}
return(Ok("File Saved"));
}
public void Given_no_backing_field_When_I_set_wrapper_value_Then_I_should_get_the_same_value()
{
// Arrange
var model = new SomeModel();
// Act
model.Message.Value = "welcome";
// Assert
model.Message.Value.Should().Be("welcome");
}
//_____________________________________________________________________________
public IActionResult AllCustomers()
{
SomeModel someModel = new SomeModel
{
Customers = db.Custumers.ToList(),
Founders = db.Founders.ToList(),
errorCarrier = ""
};
return(View(someModel));
}
private void Awake()
{
health = new SomeModel <int>(0);
StartHealth();
health.count
.ObserveEveryValueChanged(x => x.Value).Where(x => x <= 0)
.Subscribe(xs => {
Death();
}).AddTo(this);
}
public void GetLinkAsyncReturnsCorrectUriForExpressionOfFuncWithComplexParameter(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUriAsync <ModelAsyncController, object>(a => a.Get(someModel)).Result;
var actual = sut.GetLinkAsync <ModelAsyncController, object>(a => a.Get(someModel)).Result;
Assert.Equal(expected, actual);
}
public void Given_I_have_selected_from_one_wrapper_When_I_change_source_Then_selected_value_should_change_accordingly()
{
// Arrange
var model = new SomeModel();
var adjustedCount = model.Count.Select(x => x + 3);
// Act
model.Count.Value = 2;
// Assert
adjustedCount.Value.Should().Be(2 + 3);
}
public IActionResult Index()
{
SomeModel jsonModel = new SomeModel();
jsonModel.UserId = "cdb86aea-e3d6-4fdd-9b7f-55e12b710f78";
jsonModel.UserName = "******";
var serializedJsonModel = JsonConvert.SerializeObject(jsonModel);
ViewBag.name = serializedJsonModel;
return(View());
}
public void Given_I_have_selected_from_two_sources_When_any_of_them_changed_Then_selected_value_should_be_changed_accordingly()
{
// Arrange
var model = new SomeModel();
// Act
model.Message.Value = "hey";
model.Count.Value = 1;
// Assert
model.DetailedMessage.Value.Should().Be(model.Message.Value + "-" + model.Count.Value);
}
public void GetLinkReturnsCorrectUriForExpressionOfActionWithComplexParameter(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut,
SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri <ModelController>(a => a.Get(someModel));
var actual = sut.GetLink <ModelController>(a => a.Get(someModel));
Assert.Equal(expected, actual);
}
public void ValueForModel_ReturnsModelValueWithSpecificFormat()
{
// Arrange
var model = new SomeModel {
SomeProperty = "ModelValue"
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model);
// Act
var result = helper.ValueForModel(format: "-{0}-");
// Assert
Assert.Equal("-{ SomeProperty = ModelValue }-", result);
}
public void Given_backing_field_When_its_wrapper_set_to_new_value_Then_PC_event_should_be_raised()
{
// Arrange
var model = new SomeModel();
var propertyChangedRaised = false;
model.Count.PropertyChanged += (sender, args) => propertyChangedRaised = true;
// Act
model.Count.Value = 3;
// Assert
propertyChangedRaised.Should().BeTrue();
}
public void Given_I_have_selected_from_one_wrapper_When_I_change_source_Then_PC_event_should_be_raised_for_selected_wrapper()
{
// Arrange
var model = new SomeModel();
var adjustedCount = model.Count.Select(x => x + 3);
var raised = false;
adjustedCount.PropertyChanged += (sender, args) => raised = true;
// Act
model.Count.Value = 2;
// Assert
raised.Should().BeTrue();
}
/// <summary>
/// Log the incomming data and send it back to the caller only
/// </summary>
/// <param name="model"></param>
public void LogTest(SomeModel model)
{
try
{
//Get the logger and write with level information
Composable.GetExport<IXLogger>().Information("LogTest: {@model}", model);
//And... throw...
throw new Exception("Ohh crap!");
}
catch (Exception ex)
{
Composable.GetExport<IXLogger>().Error("LogTest: {@ex}", ex);
}
}
public void ValueForModel_ReturnsModelValue()
{
// Arrange
var model = new SomeModel {
SomeProperty = "ModelValue"
};
var helper = DefaultTemplatesUtilities.GetHtmlHelper(model);
// Act
var result = helper.ValueForModel();
// Assert
Assert.Equal("{ SomeProperty = ModelValue }", result);
}
public void OnChange_should_not_call_handler_when_subscriber_is_collected()
{
// Arrange
var observer = new Observer();
var model = new SomeModel(observer);
var counter = Reactive.Of(0).OnChange(model.Change);
// Act
model = null;
GC.Collect();
counter.Value = 1;
// Assert
observer.ChangedObserved.Should().BeFalse();
}
public void Action_event_handler_should_be_called_on_event()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
SubscribeWeakly.OnGenericAction<SomeDataChangedEvent, SomeView>(
h => model.SomeDataChanged += h,
h => model.SomeDataChanged -= h,
view, (v, e) => v.OnSomeDataChanged());
// Act
model.NotifySomeDataChanged(new SomeDataChangedEvent());
// Assert
view.Observer.IsSomeDataChangedHandled.Should().BeTrue();
}
public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected2()
{
// Arrange
var observer = new Observer();
var model = new SomeModel(observer);
var counter = Reactive.Of(0);
counter.SubscribeWeakly(x => x.Value, model.Change);
// Act
model = null;
GC.Collect();
counter.Value = 1;
// Assert
observer.ChangedObserved.Should().BeFalse();
}
public void Action_event_handler_should_not_be_called_when_subscription_is_disposed()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
var subscription = SubscribeWeakly.OnGenericAction<SomeDataChangedEvent, SomeView>(
h => model.SomeDataChanged += h,
h => model.SomeDataChanged -= h,
view,
(x, e) => x.OnSomeDataChanged());
// Act
subscription.Dispose();
model.NotifySomeDataChanged(new SomeDataChangedEvent());
// Assert
view.Observer.IsSomeDataChangedHandled.Should().BeFalse();
}
public void Action_event_handler_should_not_be_called_when_GC_collected_and_subscriber_is_not_used_aftrewards()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
SubscribeWeakly.OnGenericAction<SomeDataChangedEvent, SomeView>(
h => model.SomeDataChanged += h,
h => model.SomeDataChanged -= h,
view, (v, e) => v.OnSomeDataChanged());
// Act
var observer = view.Observer;
// ReSharper disable RedundantAssignment
view = null;
// ReSharper restore RedundantAssignment
GC.Collect();
model.NotifySomeDataChanged(new SomeDataChangedEvent());
// Assert
observer.IsSomeDataChangedHandled.Should().BeFalse();
}
public void Generic_EventHandler_event_handler_should_be_called_on_event()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
SubscribeWeakly.OnGenericEventHandler<OtherDataChangedEvent, SomeView>(
h => model.OtherDataChanged += h,
h => model.OtherDataChanged -= h,
view, (v, sender, e) => v.OnOtherDataChanged());
// Act
model.NotifyOtherDataChanged(new OtherDataChangedEvent());
// Assert
view.Observer.IsOtherDataChangedHandled.Should().BeTrue();
}
public void Given_no_backing_field_When_I_set_wrapper_value_Then_I_should_get_the_same_value()
{
// Arrange
var model = new SomeModel();
// Act
model.Message.Value = "welcome";
// Assert
model.Message.Value.Should().Be("welcome");
}
public void Action_event_subscription_can_be_safely_disposed_multiple_times()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
var subscription = SubscribeWeakly.OnGenericAction<SomeDataChangedEvent, SomeView>(
h => model.SomeDataChanged += h,
h => model.SomeDataChanged -= h,
view, (x, e) => { });
// Act
subscription.Dispose();
subscription.Dispose();
// Assert
// No exception should be raised
}
public void Given_I_have_selected_from_one_wrapper_When_I_change_source_Then_selected_value_should_change_accordingly()
{
// Arrange
var model = new SomeModel();
var adjustedCount = model.Count.Select(x => x + 3);
// Act
model.Count.Value = 2;
// Assert
adjustedCount.Value.Should().Be(2 + 3);
}
public void OnActionExecuted(ActionExecutedContext filterContext)
{
Model = (SomeModel) ((ModelResult)filterContext.Result).Model;
}
public void PropertyChanged_should_not_call_weakly_subscribed_subscriber_when_subscriber_is_collected()
{
// Arrange
var observer = new Observer();
var model = new SomeModel(observer);
var counter = Reactive.Of(0);
counter.SubscribeWeakly(model, (m, s, e) => m.Change(s));
// Act
model = null;
GC.Collect();
counter.Value = 1;
// Assert
observer.ChangedObserved.Should().BeFalse();
}
public void EventHandler_event_handler_should_not_be_called_when_subscriber_is_garbage_collected()
{
// Arrange
var view = new SomeView();
var model = new SomeModel();
SubscribeWeakly.OnEventHandler(
h => model.Updated += h,
h => model.Updated -= h,
view, (v, sender, e) => v.OnOtherDataChanged());
// Act
var observer = view.Observer;
// ReSharper disable RedundantAssignment
view = null;
// ReSharper restore RedundantAssignment
GC.Collect();
model.Update();
// Assert
observer.IsOtherDataChangedHandled.Should().BeFalse();
}
public void Given_I_have_selected_from_two_sources_When_one_of_them_changed_Then_PC_event_should_be_raised_for_selected_wrapper()
{
// Arrange
var model = new SomeModel();
var raised = false;
model.DetailedMessage.PropertyChanged += (sender, args) => raised = true;
// Act
model.Count.Value += 1;
// Assert
raised.Should().BeTrue();
}
public void Given_I_have_selected_from_two_sources_When_selected_result_not_in_use_And_sources_are_changed_Then_no_exception_should_be_raised()
{
// Arrange
var model = new SomeModel();
var detailedMessage = NotifyChange.Select(() => model.Message.Value + model.Count.Value, model.Count, model.Message);
var detailedMessageWeakRef = new WeakReference(detailedMessage);
// Act
// ReSharper disable RedundantAssignment
detailedMessage = null;
// ReSharper restore RedundantAssignment
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
// Assert
Assert.DoesNotThrow(() =>
{
model.Count.Value += 1;
model.Message.Value = "hey";
});
detailedMessageWeakRef.IsAlive.Should().BeFalse();
}
public void Given_I_have_selected_from_two_sources_When_any_of_them_changed_Then_selected_value_should_be_changed_accordingly()
{
// Arrange
var model = new SomeModel();
// Act
model.Message.Value = "hey";
model.Count.Value = 1;
// Assert
model.DetailedMessage.Value.Should().Be(model.Message.Value + "-" + model.Count.Value);
}
public void Given_I_have_selected_from_two_sources_When_selected_result_not_in_use_anymore_and_GC_Then_selected_result_should_be_collected()
{
// Arrange
var model = new SomeModel();
var doubleCount = NotifyChange.Select(() => model.Count.Value * 2, model.Count);
var doubleCountWeakRef = new WeakReference(doubleCount);
// Act
// ReSharper disable RedundantAssignment
doubleCount = null;
// ReSharper restore RedundantAssignment
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
// Assert
doubleCountWeakRef.IsAlive.Should().BeFalse();
model.Count.Value.Should().Be(0);
}
public void When_POST_typed_JSON_content_can_be_read()
{
var reqModel = new SomeModel
{
AnInteger = 2,
AString = "hello"
};
var client = new HttpClient();
client.PostAsJsonAsync(_baseAddress + "Test", reqModel);
TestController.OnPost(req =>
{
var recModel = req.Content.ReadAsAsync<SomeModel>().Result;
Assert.Equal(reqModel.AnInteger, recModel.AnInteger);
Assert.Equal(reqModel.AString, recModel.AString);
return new HttpResponseMessage();
});
}
