public void ShouldBeThrowArgumentNullException()
{
var fakeCustomers = new Faker <Customer>()
.Rules((f, o) => o.Name = f.Name.FullName())
.Generate(100)
.AsQueryable();
var pageable = new RSqlPageable <Customer>(0, 10);
var controller = new MockController();
var query = new RSqlQuery <Customer>(c => c.Name != string.Empty);
var page = fakeCustomers.Page(pageable, query);
// controllerBase is null
this.Invoking((o) =>
ControllerBaseExtensions.Page(
null,
page))
.Should()
.Throw <ArgumentNullException>();
// page is null
this.Invoking((o) =>
ControllerBaseExtensions.Page <Customer>(controller,
null))
.Should()
.Throw <ArgumentNullException>();
}
public void ShouldBePartialContent()
{
var fakeCustomers = new Faker <Customer>()
.Rules((f, o) => o.Name = f.Name.FullName())
.Generate(100)
.AsQueryable();
Helper.Expression <Customer>("name=is-null=false");
var pageable = new RSqlPageable <Customer>(0, 10);
var controller = new MockController();
var page = fakeCustomers.Page(pageable);
var expected = controller.Page(page);
expected
.Should().BeOfType <ObjectResult>();
((ObjectResult)expected).StatusCode
.Should().Be((int)HttpStatusCode.PartialContent);
((ObjectResult)expected).Value.As <IRSqlPage <Customer> >()
.Should().NotBeNull();
((IRSqlPage <Customer>)((ObjectResult)expected).Value).Content
.Count.Should().Be(10);
((IRSqlPage <Customer>)((ObjectResult)expected).Value).HasNext
.Should().BeTrue();
}
public async Task List()
{
var env = new UnitTestEnvironment();
await env.Run(async sp =>
{
var databaseContext = sp.GetRequiredService <IDatabaseContext>();
await DataCommon.DataInitAsync(databaseContext);
});
Guid id = Guid.Empty;
string username = null;
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var model = await controller.ExecuteAsync <EntityDomainService <User>, IEntityViewModel <User> >("List");
Assert.Equal(2, model.Items.Length);
id = model.Items[0].Index;
username = model.Items[0].Username;
});
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var model = await controller.ExecuteAsync <EntityDomainService <User>, IEntityEditModel <User> >(context =>
{
context.ValueProvider.SetAlias("id", "Index");
context.ValueProvider.SetValue("id", id);
}, "Detail");
Assert.Equal(username, model.Item.Username);
});
}
[ExpectedException(typeof(Exception))] //delete through GET should not be allowed
public void Get_Delete()
{
dynamic webPage = new MockGet(new string[] { "Mock", "Delete", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
controller.Verify();
}
public void AppendAlertWithNullAlertArgument_ShouldThrowException()
{
ControllerBase controllerBase = new MockController();
AlertDetail alert = null;
AlertManager.AppendAlert(controllerBase, alert);
Assert.Fail("Should have thrown ArgumentNullException.");
}
public void ReturnsNotFoundObjectResult()
{
var controller = new MockController();
var result = Result <object> .NotFound();
var actionResult = result.ToActionResult(controller);
Assert.IsType <NotFoundResult>(actionResult.Result);
}
public void Get_Edit_Pass_String()
{
dynamic webPage = new MockGet(new string[] { "Mock", "Edit", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
controller.Verify();
}
public void Routing_Post()
{
dynamic webPage = new MockPost(new string[] { "Mock", "a", "b", "c" }, null);
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.Post_Called);
controller.Verify();
}
public void Routing_Get()
{
dynamic webPage = new MockGet(new string[] { "Mock", "a", "1", "2" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.Get_Called);
controller.Verify();
}
public void Post_Delete()
{
dynamic webPage = new MockPost(new string[] { "Mock", "Delete", "y", "z" }, null);
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
controller.Verify();
}
public void Setup()
{
factory = new MockRepository(MockBehavior.Default);
var controller = new MockController();
var context = factory.Create<HttpContextBase>();
response = factory.Create<HttpResponseBase>();
context.Setup(c => c.Response).Returns(response.Object);
controllerContext = controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
}
public void ReturnsOkObjectResult()
{
var controller = new MockController();
var result = new Result <object>(new object());
var actionResult = result.ToActionResult(controller);
Assert.IsType <OkObjectResult>(actionResult.Result);
}
public void Start_NullConnectionPool_ArgumentNullException()
{
// Arrange
var controller = new MockController();
// Act/Assert
Assert.Throws <ArgumentNullException>(() => controller.Start(null));
}
public void SetUp()
{
_repositoryMock = new Mock<ICrudRepository<MockEntity1>>(MockBehavior.Strict);
_controller = new MockController(_repositoryMock.Object)
{
Request = new HttpRequestMessage {RequestUri = new Uri("http://fake/")},
Configuration = new HttpConfiguration()
};
}
public void Routing_All()
{
dynamic webPage = new MockGet(new string[] { "Mock", "x", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.All_Called);
Assert.AreEqual("y", controller.UrlData[1]);
Assert.AreEqual("z", controller.UrlData[2]);
controller.Verify();
}
void OnClick()
{
if (!LevelManager.Instance.mapInfoController.gameObject.activeInHierarchy)
{
LevelManager.Instance.mapInfoController.gameObject.SetActive(true);
MockController controller = transform.parent.GetComponent <MockController>();
MapInfoController mapInfoController = LevelManager.Instance.mapInfoController;
mapInfoController.initalize(controller.mapName, controller.mapID, starSuccess);
}
}
public IntegrationTest()
{
var provider = new ServiceCollection()
.AddSingleton <IScopedStorage <DbContext> >(
s => new ScopedStorage <DbContext> {
Value = this.database.Create()
})
.BuildServiceProvider();
this.controller = new MockController(provider);
}
public void RenderAlertMessagesFromQueueWithValidArgumentAndValidMessage_ReturnsExpected()
{
String expected = "\r\n<script>$().ready(function () { addAlertToMessageArea(0, 'No message set.',0,1); });</script>\r\n\r\n";
String actual = String.Empty;
Controller controller = new MockController();
AlertManager.AppendAlert(controller, new AlertDetail());
HtmlHelper instance = new MockHtmlHelper();
instance.ViewContext.Controller = controller;
actual = HtmlHelperExtensions.RenderAlertMessagesFromQueue(instance);
Assert.AreEqual(expected, actual);
}
public static ControllerContext SetupMockControllerHeaders(System.Net.WebHeaderCollection headers)
{
var req = new Mock<HttpRequestBase>();
var rsp = new Mock<HttpResponseBase>();
req.SetupGet(x => x.Headers).Returns(
new System.Net.WebHeaderCollection { headers }
);
var context = new Mock<HttpContextBase>();
context.Setup(ctx => ctx.Request).Returns(req.Object);
context.Setup(ctx => ctx.Response).Returns(rsp.Object);
var mock_controller = new MockController();
var mock_controller_context = new ControllerContext(context.Object, new RouteData(), mock_controller);
return mock_controller_context;
}
private Controller CreateMockController(bool addModelStateErrors)
{
var mockController = new MockController();
if (addModelStateErrors)
{
var state = new ModelState();
state.Errors.Add(new FormatException());
state.Value = new ValueProviderResult("1,44", "1.44", new System.Globalization.CultureInfo("fi-FI"));
mockController.ViewData.ModelState.Add("test", state);
}
return(mockController);
}
public void Start_Disposed_ObjectDisposedException()
{
// Arrange
var connectionPool = new Mock <IConnectionPool>();
var controller = new MockController();
controller.Dispose();
// Act/Assert
Assert.Throws <ObjectDisposedException>(() => controller.Start(connectionPool.Object));
}
public void Post_Edit_Pass_Form()
{
dynamic webPage = new MockPost(new string[] { "Mock", "Edit", "y", "z" }, null);
webPage.Request.TestValue = -20.3m;
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
Assert.AreEqual(-20.3m, controller.TestValue);
controller.Verify();
}
public void TestSettingContext()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddFluentRestBuilder();
var scope = serviceCollection.BuildServiceProvider()
.CreateScope();
var controller = new MockController(scope.ServiceProvider);
var context = new MockActionExecutingContext(controller);
var filter = new UrlHelperProviderAttribute();
filter.OnActionExecuting(context);
var storage = scope.ServiceProvider.GetService <IScopedStorage <IUrlHelper> >();
Assert.Same(controller.Url, storage.Value);
}
public void TestSettingContext()
{
var serviceProvider = new ServiceCollection()
.AddFluentRestBuilder()
.Services
.BuildServiceProvider()
.CreateScope()
.ServiceProvider;
var controller = new MockController(serviceProvider);
var context = new MockActionExecutingContext(controller);
var filter = new HttpContextProviderAttribute();
filter.OnActionExecuting(context);
var storage = serviceProvider.GetService <IScopedStorage <HttpContext> >();
Assert.Same(controller.HttpContext, storage.Value);
}
public void AppendAlertWithTempDataAlert_ShouldSaveToQueue()
{
Int32 expected = 1;
Int32 actual = 0;
ControllerBase controllerBase = new MockController();
AlertDetail alert = new AlertDetail() { AlertMessage = "Unit Test", EnableCrossView = true };
AlertManager.AppendAlert(controllerBase, alert);
Assert.IsNotNull(controllerBase.TempData["CouncilSoft.BootstrapAlerts"]);
Queue<AlertDetail> queue = controllerBase.TempData["CouncilSoft.BootstrapAlerts"] as Queue<AlertDetail>;
Assert.IsNotNull(queue);
actual = queue.Count;
Assert.AreEqual(expected, actual);
}
public static ControllerContext SetupMockControllerHeaders(System.Net.WebHeaderCollection headers)
{
var req = new Mock <HttpRequestBase>();
var rsp = new Mock <HttpResponseBase>();
req.SetupGet(x => x.Headers).Returns(
new System.Net.WebHeaderCollection {
headers
}
);
var context = new Mock <HttpContextBase>();
context.Setup(ctx => ctx.Request).Returns(req.Object);
context.Setup(ctx => ctx.Response).Returns(rsp.Object);
var mock_controller = new MockController();
var mock_controller_context = new ControllerContext(context.Object, new RouteData(), mock_controller);
return(mock_controller_context);
}
public void ReturnsInvalidObjectResult()
{
var controller = new MockController();
var result = Result <object> .Invalid(new List <ValidationError>
{
new ValidationError
{
ErrorMessage = "some error",
Identifier = "test identitifier",
Severity = ValidationSeverity.Info
}
});
var actionResult = result.ToActionResult(controller);
var errorCount = controller.ModelState.ErrorCount;
Assert.Equal(errorCount, 1);
Assert.IsType <BadRequestObjectResult>(actionResult.Result);
}
public async Task RunScalingLogic_AtMinimumSize_NoChange()
{
// Arrange
var connectionPool = CreateMockConnectionPool(
2, 2, 5, 0,
Enumerable.Range(1, 2).Select(_ => CreateMockConnection(TimeSpan.Zero)));
var controller = new MockController();
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(It.IsAny <int>()),
Times.Never);
}
public void TestAddMessages()
{
InitializeHttpContext();
var controller = new MockController();
controller.InfoMessage("情報メッセージ1");
controller.InfoMessage("情報メッセージ2");
controller.SuccessMessage("success");
controller.WarnMessage("warn");
controller.ErrorMessage("error");
var store = FeedbackMessageStore.Current;
Assert.AreEqual(5, store.Count);
Assert.AreEqual(2, store.GetFeedbackMessages(FeedbackMessageLevel.INFO).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.SUCCESS).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.WARN).Count);
Assert.AreEqual(1, store.GetFeedbackMessages(FeedbackMessageLevel.ERROR).Count);
}
public async Task RunScalingLogic_AboveBackPressureThreshold_ScaleUp()
{
// Arrange
var connectionPool = CreateMockConnectionPool(
2, 2, 5, 5,
Enumerable.Range(1, 2).Select(_ => CreateMockConnection(TimeSpan.Zero)));
var controller = new MockController
{
BackPressureThreshold = 4
};
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(1),
Times.Once);
}
public async Task RunScalingLogic_AtOrBelowBackPressureThreshold_NoChange(int backPressure)
{
// Arrange
var connectionPool = CreateMockConnectionPool(
5, 2, 5, backPressure,
Enumerable.Range(1, 2).Select(_ => CreateMockConnection(TimeSpan.Zero)));
var controller = new MockController
{
BackPressureThreshold = 4
};
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(It.IsAny <int>()),
Times.Never);
}
public async Task RunScalingLogic_AllConnectionsBelowTimeout_NoChange(int lastActivitySeconds)
{
// Arrange
var connectionPool = CreateMockConnectionPool(
2, 2, 5, 0,
Enumerable.Range(1, 2).Select(_ => CreateMockConnection(TimeSpan.FromSeconds(lastActivitySeconds))));
var controller = new MockController
{
IdleConnectionTimeout = TimeSpan.FromSeconds(60)
};
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(It.IsAny <int>()),
Times.Never);
}
public async Task RunScalingLogic_BelowMinimumSize_ScaleUp()
{
// Arrange
const int minConnectionPoolSize = 2;
var connectionPool = CreateMockConnectionPool(
0, minConnectionPoolSize, 5, 0,
Enumerable.Range(1, 1).Select(_ => CreateMockConnection(TimeSpan.Zero)));
var controller = new MockController
{
BackPressureThreshold = 4
};
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(minConnectionPoolSize),
Times.Once);
}
public async Task SyncEventTest()
{
var env = new EventTestEnvironment();
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var result = await controller.ExecuteAsync <EventDomainService, double>(context =>
{
context.ValueProvider.SetValue("value", 1.0);
}, "SyncEventTest");
Assert.Equal(4, result);
});
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var result = await controller.ExecuteAsync <EventDomainService, double>(context =>
{
context.ValueProvider.SetValue("value", 2.0);
context.EventManager.AddEventHandler <OperatorEventArgs>(EventDomainService.SyncOperatorEvent, (ec, e) =>
{
e.Value *= 2;
});
}, "SyncEventTest");
Assert.Equal(7, result);
});
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var result = await controller.ExecuteAsync <EventDomainService, double>(context =>
{
context.ValueProvider.SetValue("value", 2.0);
}, "SyncEventTest");
Assert.Equal(5, result);
});
}
public async Task RunScalingLogic_OneConnectionAboveTimeout_ScaleDown()
{
// Arrange
var connectionPool = CreateMockConnectionPool(
5, 2, 5, 0,
Enumerable.Range(1, 5).Select(i =>
CreateMockConnection(i < 5 ? TimeSpan.Zero : TimeSpan.FromSeconds(60))));
var controller = new MockController
{
IdleConnectionTimeout = TimeSpan.FromSeconds(60)
};
// Act
await controller.RunScalingLogicPublic(connectionPool.Object);
// Assert
connectionPool.Verify(
m => m.ScaleAsync(-1),
Times.Once);
}
public async Task List2()
{
var env = new UnitTestEnvironment();
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
await controller.ExecuteAsync <DataCommonService>("DataInit");
});
Guid id;
string username;
await env.Run(async sp =>
{
MockController controller = new MockController(sp);
var model = await controller.ExecuteAsync <EntityDomainService <User>, IEntityViewModel <User> >("List");
Assert.Equal(2, model.Items.Length);
id = model.Items[0].Index;
username = model.Items[0].Username;
var category = await model.Items[0].LoadAsync(t => t.Category);
var userQueryable = await category.LoadAsync(t => t.Users);
var users = userQueryable.ToArrayAsync();
});
}
public void Routing_Get()
{
dynamic webPage = new MockGet(new string[] { "Mock", "a", "1", "2" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.Get_Called);
controller.Verify();
}
public void Get_Edit_Pass_String()
{
dynamic webPage = new MockGet(new string[] { "Mock", "Edit", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
controller.Verify();
}
public void Get_Delete()
{
dynamic webPage = new MockGet(new string[] { "Mock", "Delete", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
controller.Verify();
}
public void Routing_Post()
{
dynamic webPage = new MockPost(new string[] { "Mock", "a", "b", "c" }, null);
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.Post_Called);
controller.Verify();
}
public void Post_Delete()
{
dynamic webPage = new MockPost(new string[] { "Mock", "Delete", "y", "z" }, null);
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
controller.Verify();
}
private FoodsController CreateController(bool isAjax = false)
{
MockController<FoodsController> controller = new MockController<FoodsController>();
return controller.GetController(isAjax);
}
public void Post_Edit_Pass_Form()
{
dynamic webPage = new MockPost(new string[] { "Mock", "Edit", "y", "z" }, null);
webPage.Request.TestValue = -20.3m;
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.AreEqual("y/z", controller.Id);
Assert.AreEqual(-20.3m, controller.TestValue);
controller.Verify();
}
public void Routing_All()
{
dynamic webPage = new MockGet(new string[] { "Mock", "x", "y", "z" });
dynamic controller = new MockController();
Mvc.Run(webPage, controller);
Assert.IsTrue(controller.All_Called);
Assert.AreEqual("y", controller.UrlData[1]);
Assert.AreEqual("z", controller.UrlData[2]);
controller.Verify();
}
