public DummyGrpcEndpointTest()
{
_ctrl = new DummyController();
_service1 = new DummyCommandableGrpcService("dummy1");
_service2 = new DummyCommandableGrpcService("dummy2");
_client1 = new DummyCommandableGrpcClient("dummy1");
_client2 = new DummyCommandableGrpcClient("dummy2");
_grpcEndpoint = new GrpcEndpoint();
var references = References.FromTuples(
new Descriptor("pip-services3-dummies", "controller", "default", "default", "1.0"), _ctrl,
new Descriptor("pip-services3", "endpoint", "grpc", "default", "1.0"), _grpcEndpoint
);
_client1.Configure(grpcConfig);
_client2.Configure(grpcConfig);
_grpcEndpoint.Configure(grpcConfig);
_service1.SetReferences(references);
_service2.SetReferences(references);
_grpcEndpoint.OpenAsync(null).Wait();
_client1.OpenAsync(null).Wait();
_client2.OpenAsync(null).Wait();
}
public void Process(string templateName, TextWriter output, IDictionary parameters)
{
DummyController controller = new DummyController();
ControllerContext context = new ControllerContext();
context.PropertyBag = parameters;
bve.Process(templateName, output, null, controller, context);
}
public void Index_ReturnsExpectedData()
{
// Arrange
DummyEntity[] data =
{
new DummyEntity {
Name = "Some Name", Id = 1
},
new DummyEntity {
Name = "Other Name", Id = 2
}
};
Mock <IDummyService> dummyService = new Mock <IDummyService>();
dummyService.Setup(e => e.FindAll()).Returns(data);
DummyController dummyController = new DummyController(dummyService.Object);
// Act
IActionResult result = dummyController.Index();
// Assert
IEnumerable <DummyEntity> objectResult = (result as OkObjectResult)?.Value as IEnumerable <DummyEntity>;
CollectionAssert.AreEqual(data, objectResult.ToList());
}
public void GetIndexRenderMode_NoAttributeController_ReturnsNormal()
{
var controller = new DummyController();
var result = controller.GetIndexRenderMode();
Assert.AreEqual(IndexRenderModes.Normal, result, "Default value for IndexRenderMode was not correct.");
}
public DummyCommandableGrpcClientTest()
{
_ctrl = new DummyController();
_service = new DummyCommandableGrpcService();
_client = new DummyCommandableGrpcClient();
var references = References.FromTuples(
new Descriptor("pip-services3-dummies", "controller", "default", "default", "1.0"), _ctrl,
new Descriptor("pip-services3-dummies", "service", "grpc", "default", "1.0"), _service,
new Descriptor("pip-services3-dummies", "client", "grpc", "default", "1.0"), _client
);
_service.Configure(GrpcConfig);
_client.Configure(GrpcConfig);
_client.SetReferences(references);
_service.SetReferences(references);
_service.OpenAsync(null).Wait();
_fixture = new DummyClientFixture(_client);
_client.OpenAsync(null).Wait();
}
public void ResultFormat_should_be_detected_from_accept_types_when_no_format_is_specified(string accpetTypes, ApiResponseFormat format)
{
var httpContext = MvcTestHelper.CreateHttpContext();
httpContext.SetupGet(c => c.Request.AcceptTypes).Returns(accpetTypes.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
httpContext.SetupGet(c => c.Request.UserHostAddress).Returns("192,168.0.1");
var routeData = new RouteData();
routeData.Values.Add("controller", "dummy");
routeData.Values.Add("action", "Process");
var requestContext = new RequestContext(httpContext.Object, routeData);
var valueProvider = new Mock <IValueProvider>();
var controller = new DummyController {
ValueProvider = valueProvider.Object
};
var controllerContext = new ControllerContext(requestContext, controller);
controller.ControllerContext = controllerContext;
var bindingContext = new ModelBindingContext
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(DummyCommand)),
ValueProvider = valueProvider.Object,
ModelName = "command",
FallbackToEmptyPrefix = true
};
var command = (DummyCommand) new ApiCommandBinder().BindModel(controllerContext, bindingContext);
Assert.Equal(format, command.ResponseFormat);
}
public void SetupTest()
{
StartTest();
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
}
public void Constroller_Return_All_Product_To_View()
{
//Arrange
Mock <IProductRepository> MoqProductRepository = new Mock <IProductRepository>();
MoqProductRepository.Setup(e => e.AllProduct()).Returns(
new List <Product>()
{
new Product {
Id = 0, Name = "Product HK"
},
new Product {
Id = 1, Name = "Product CN"
}
}
);
DummyController Controller = new DummyController(null);
//Act
ViewResult VR = Controller.GetAllAction() as ViewResult;
var Model = VR.Model as List <Product>;
//Assert
Assert.IsTrue(Model.Count == 2, "Expected Product Count is 2 ; Actual is" + Model.Count);
Assert.IsTrue(Model[0].Name == "Product HK", "Expected 1st Product Name is Product HK ; Actual is " + Model[0].Name);
}
public void Get_ServiceReturnsNumber_CorrectResponseProvided()
{
// ARRANGE
string word = "word";
int numberOfCharacters = 4;
string expectedResponse = $"The word '{word}' contains {numberOfCharacters} characters.";
Mock <ICountCharactersService> mock = new Mock <ICountCharactersService>();
mock
.Setup(m => m.CountCharacters(It.IsAny <string>()))
.Returns(numberOfCharacters);
DummyController controller = new DummyController(mock.Object);
// ACT
IActionResult response = controller.Get(word);
// ASSERT
Assert.IsType <OkObjectResult>(response);
OkObjectResult okResponse = (OkObjectResult)response;
Assert.IsType <string>(okResponse.Value);
string content = (string)okResponse.Value;
Assert.Equal(expectedResponse, content);
}
public DummyCommandableHttpClientTest()
{
_ctrl = new DummyController();
_service = new DummyCommandableHttpService();
_client = new DummyCommandableHttpClient();
var references = References.FromTuples(
new Descriptor("pip-services3-dummies", "controller", "default", "default", "1.0"), _ctrl,
new Descriptor("pip-services3-dummies", "service", "rest", "default", "1.0"), _service,
new Descriptor("pip-services3-dummies", "client", "rest", "default", "1.0"), _client
);
_service.Configure(RestConfig);
_client.Configure(RestConfig);
_client.SetReferences(references);
_service.SetReferences(references);
_service.OpenAsync(null).Wait();
_fixture = new DummyClientFixture(_client);
_source = new CancellationTokenSource();
_client.OpenAsync(null).Wait();
}
public async Task ErrorSetIsReturned(ErrorSet errorSet)
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
controller.Request.Headers.Accept.Clear();
controller.Request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var statusCode = HttpStatusCode.MethodNotAllowed;
var actionResult = new FailureWithErrorSetResult(statusCode, controller, errorSet);
var response = await actionResult.ExecuteAsync(new CancellationToken());
var responseSet = await response.Content.ReadAsAsync <ErrorSet>();
responseSet.Should().NotBeNull("because an error set should be present in the response");
responseSet.Errors.Should().NotBeNull("because there should be an error collection present in the response, even if empty");
var expectedErrors = errorSet.Errors.OrderBy(item => item.Code).ToList();
var responseErrors = responseSet.Errors.OrderBy(item => item.Code).ToList();
responseErrors.Should().HaveSameCount(expectedErrors, "because the number of errors in the result should match the provided error set")
.And.Equal(expectedErrors, (left, right) => ((left.Code == right.Code) && (left.Description == right.Description)), "because the provided error set should have been used in the response");
}
public void Initialize()
{
_controller = new DummyController();
var userData = @"{
'Id' : '6C50D4C1-B608-4EFA-B488-C95DBC6F9BA6',
'Roles' : [ 'Editor' ],
'SessionTimeout' : 60,
'RealName' : 'Dummy User',
'StartContentNode' : '',
'StartMediaNode' : '',
'AllowedApplications' : [ 'Content', 'Media' ]
}";
var ticket = new FormsAuthenticationTicket(1, "DummyUser", DateTime.Now.AddHours(-1), DateTime.Now.AddHours(1), false, userData);
var identity = new RebelBackOfficeIdentity(ticket);
var user = Substitute.For<IPrincipal>();
user.Identity.Returns(identity);
var httpContext = Substitute.For<HttpContextBase>();
httpContext.User.Returns(user);
var routeData = new RouteData();
var context = new RequestContext(httpContext, routeData);
var controllerContext = new ControllerContext(context, _controller);
_controller.ControllerContext = controllerContext;
}
public void PostingABodyReturnsAValidAbsoluteURL()
{
//Arrange
var key = "abcdef1234";
var testData = "Test data";
var serviceName = "service name";
var mockService = new MockService(key, serviceName, testData);
var responseRepository = new Mock <IMockServiceStore>();
var controller = new DummyController(responseRepository.Object)
{
Request = request
};
responseRepository.Setup(x => x.CreateAsync(mockService));
dynamic service = new object();
service.name = "Unit test name";
//Act
var returnedString = controller.Post(service);
//Assert
var url = new Uri(returnedString.ToString());
Assert.IsTrue(url.IsAbsoluteUri);
}
public async Task TestPublishAfterGC()
{
App.Current.EventsBroker = new EventsBroker();
// We lose the old controller and garbage collect it.
controller = null;
GC.Collect();
GC.WaitForPendingFinalizers();
unmanagedDisposeCalled = false;
managedDisposeCalled = false;
// We create a new controller and add a WeakReference to it
WeakReference controllerRef = await CreateAndLoseController();
Assert.IsNotNull(controllerRef.Target);
do
{
GC.Collect();
GC.WaitForPendingFinalizers();
} while (controllerRef.Target != null);
// Act
// Publish an event to the collected controller
await App.Current.EventsBroker.Publish <NewTagEvent> ();
// Assert
Assert.IsTrue(unmanagedDisposeCalled);
Assert.IsFalse(managedDisposeCalled);
Assert.IsFalse(answered);
}
public void Initialize()
{
_controller = new DummyController();
var userData = @"{
'Id' : '6C50D4C1-B608-4EFA-B488-C95DBC6F9BA6',
'Roles' : [ 'Editor' ],
'SessionTimeout' : 60,
'RealName' : 'Dummy User',
'StartContentNode' : '',
'StartMediaNode' : '',
'AllowedApplications' : [ 'Content', 'Media' ]
}";
var ticket = new FormsAuthenticationTicket(1, "DummyUser", DateTime.Now.AddHours(-1), DateTime.Now.AddHours(1), false, userData);
var identity = new RebelBackOfficeIdentity(ticket);
var user = Substitute.For <IPrincipal>();
user.Identity.Returns(identity);
var httpContext = Substitute.For <HttpContextBase>();
httpContext.User.Returns(user);
var routeData = new RouteData();
var context = new RequestContext(httpContext, routeData);
var controllerContext = new ControllerContext(context, _controller);
_controller.ControllerContext = controllerContext;
}
public DummyHttpEndpointTest()
{
_ctrl = new DummyController();
_serviceV1 = new DummyCommandableHttpService();
_serviceV2 = new DummyCommandableHttpService();
_httpEndpoint = new HttpEndpoint();
var references = References.FromTuples(
new Descriptor("pip-services3-dummies", "controller", "default", "default", "1.0"), _ctrl,
new Descriptor("pip-services3", "endpoint", "http", "default", "1.0"), _httpEndpoint
);
_serviceV1.Configure(ConfigParams.FromTuples(
"base_route", "/api/v1/dummy"
));
_serviceV2.Configure(ConfigParams.FromTuples(
"base_route", "/api/v2/dummy"
));
_httpEndpoint.Configure(RestConfig);
_serviceV1.SetReferences(references);
_serviceV2.SetReferences(references);
_httpEndpoint.OpenAsync(null).Wait();
}
public void ShouldAddRouteIfProvidedWhenConfigureIsInvoked()
{
var route = new HttpRoute("testroute");
controller = new DummyController();
controller.ConfigureForTesting(request, "testroute", route);
controller.Configuration.Routes.ShouldContain(route);
}
public void Init()
{
viewEngineManagerMock = mockRepository.DynamicMock<IViewEngineManager>();
service = new EmailTemplateService(viewEngineManagerMock);
engineContext = new StubEngineContext(null, null, null, null);
controller = new DummyController();
controllerContext = new ControllerContext();
}
public void ShouldSetRouteDataWithControllerInformationWhenConfigureIsInvoked()
{
controller = new DummyController();
var route = new HttpRoute("testroute");
controller.ConfigureForTesting(new HttpRequestMessage(), "testroute", route);
var addedRoute = controller.Configuration.Routes["testroute"];
addedRoute.ShouldEqual(route);
}
public void Process(string templateName, TextWriter output, IDictionary parameters)
{
var controller = new DummyController();
var context = new ControllerContext
{
PropertyBag = parameters
};
bve.Process(templateName, output, null, controller, context);
}
public void Setup()
{
controller = new DummyController();
managedDisposeCalled = false;
unmanagedDisposeCalled = false;
answered = false;
controller.managedDisposeCalled += ManagedDisposeCalled;
controller.unmanagedDisposeCalled += UnmanagedDisposeCalled;
}
public void SetupTest()
{
InitializeNakedObjectsFramework(this);
RunFixturesOnce();
StartTest();
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
SetupViewData();
}
public void Init()
{
viewEngineManagerMock = mockRepository.DynamicMock <IViewEngineManager>();
service = new EmailTemplateService(viewEngineManagerMock);
engineContext = new StubEngineContext(null, null, null, null);
controller = new DummyController();
controllerContext = new ControllerContext();
}
private void CheckDistance(GameObject obj, float dist, bool controllerType)
{
if (Vector3.Distance(transform.position, obj.transform.position) <= dist && controllerType)
{
HeroController hCtrl = obj.GetComponent <HeroController>();
if (Vector3.Distance(transform.position, obj.transform.position) <= dist && controllerType)
{
if (CardColor.Equals("red"))
{
hCtrl.HasRedKeyCard = true;
}
if (CardColor.Equals("blue"))
{
hCtrl.HasBlueKeyCard = true;
}
}
hCtrl.PlayKeyCardAudio();
Destroy(this.gameObject);
}
if (Vector3.Distance(transform.position, obj.transform.position) <= dist && !controllerType)
{
DummyController dCtrl = obj.GetComponent <DummyController>();
if (Vector3.Distance(transform.position, obj.transform.position) <= dist && !controllerType)
{
if (CardColor.Equals("red"))
{
dCtrl.HasRedKeyCard = true;
}
if (CardColor.Equals("blue"))
{
dCtrl.HasBlueKeyCard = true;
}
}
dCtrl.PlayKeyCardAudio();
Destroy(this.gameObject);
}
if (Vector3.Distance(transform.position, obj.transform.position) <= dist && !controllerType &&
!spider.GetComponent <SpiderController>().destroyFlag)
{
SpiderController sCtrl = obj.GetComponent <SpiderController>();
if (CardColor.Equals("red"))
{
sCtrl.HasRedKeyCard = true;
}
if (CardColor.Equals("blue"))
{
sCtrl.HasBlueKeyCard = true;
}
sCtrl.PlayKeyCardAudio();
Destroy(this.gameObject);
}
}
public void Edit_WhenProductDoesNotExist_ReturnNotFound()
{
Product obj = null;
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(i => i.ProductRepo.GetProductById(It.IsAny <int>())).Returns(obj);
var controller = new DummyController(unitOfWork.Object);
controller.Edit(1).Should().BeOfType(typeof(HttpNotFoundResult));
}
public void TestEvents()
{
DummyController controller = new DummyController();
var clock = controller.Clock;
Assert.IsNotNull(clock);
Assert.IsFalse(clock.IsRunning);
controller.MountAudio(new DummyAudio());
Assert.IsTrue(clock.IsRunning);
controller.MountAudio(null);
Assert.IsFalse(clock.IsRunning);
Assert.IsFalse(clock.IsPlaying);
controller.Play();
Assert.AreEqual(0f, clock.CurrentTime, Delta);
Assert.IsTrue(clock.IsPlaying);
controller.Play(2000f);
Assert.AreEqual(0f, clock.CurrentTime, Delta);
controller.Stop();
Assert.IsFalse(clock.IsPlaying);
Assert.IsFalse(clock.IsPaused);
Assert.IsTrue(clock.IsStopped);
controller.Play(2000f);
Assert.AreEqual(-2000f, clock.CurrentTime, Delta);
Assert.IsTrue(clock.IsPlaying);
Assert.IsFalse(clock.IsPaused);
Assert.IsFalse(clock.IsStopped);
controller.Pause();
Assert.AreEqual(-2000f, clock.CurrentTime, Delta);
Assert.IsFalse(clock.IsPlaying);
Assert.IsTrue(clock.IsPaused);
Assert.IsFalse(clock.IsStopped);
controller.Stop();
Assert.AreEqual(0f, clock.CurrentTime, Delta);
Assert.AreEqual(1f, clock.Rate);
controller.SetTempo(2f);
Assert.AreEqual(2f, clock.Rate, Delta);
Assert.AreEqual(0f, clock.CurrentTime, Delta);
controller.Seek(5000f);
Assert.AreEqual(10000f, clock.CurrentTime, Delta);
controller.SetTempo(1f);
Assert.AreEqual(5000, clock.CurrentTime, Delta);
clock.Offset = 1000f;
Assert.AreEqual(6000f, clock.CurrentTime, Delta);
}
public void CanRenderViewWithoutUsingFullMonoRailPipeline()
{
BooViewEngine bve = new BooViewEngine();
string viewPath = Path.Combine(ConfigurationManager.AppSettings["tests.src"], "Views");
bve.Service(new ViewSourceLoaderServiceProvider(viewPath));
bve.Initialize();
StringWriter sw = new StringWriter();
DummyController controller = new DummyController();
PrepareController(controller, "", "home", "index");
bve.Process(sw, Context, controller, "home/index");
Assert.AreEqual("Brail is wonderful", sw.ToString());
}
public async Task RetryAfterIsNotSetWhenTimeSpanNotSet()
{
var controller = new DummyController()
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new ServiceUnavailableResult(controller, new TimeSpan());
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Headers.RetryAfter.Should().BeNull("because the response should not specify the Retry-After");
}
public void SetupTest()
{
InitializeNakedObjectsFramework(this);
RunFixturesOnce();
StartTest();
Surface = GetConfiguredContainer().Resolve <IFrameworkFacade>();
NakedObjectsFramework = ((dynamic)Surface).Framework;
MessageBroker = NakedObjectsFramework.MessageBroker;
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
SetupViewData();
}
public async void HttpStatusCodeIsCorrect()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse());
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.StatusCode.Should().Be(HttpStatusCode.Accepted, "because the result should set the provided status code");
}
public async Task RetryAfterIsNotSetForTimeSpanZero()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse(), TimeSpan.Zero);
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Headers.RetryAfter.Should().BeNull("because the response should not specify the Retry-After.");
}
public async Task RetryAfterIsNotSetWhenNoTimeSpanIsProvided()
{
var controller = new DummyController
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new AcceptedResult <DummyResponse>(controller, new DummyResponse());
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.Content.Headers.Should().NotContain("Retry-After", "because the response should not specify the Retry-After.");
}
public void ShouldGetEmployees()
{
//AAA
//Arrange
DummyController controller = new DummyController();
//Act
object result = controller.GetTest();
//Assert
Assert.IsNotNull(result);
}
public async Task HttpStatusCodeIsCorrect()
{
var controller = new DummyController()
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
var actionResult = new ServiceUnavailableResult(controller, TimeSpan.FromSeconds(5));
var response = await actionResult.ExecuteAsync(new CancellationToken());
response.StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable, "because the result should set the provided status code");
}
protected string ProcessView(IDictionary dictionary, string templatePath)
{
BooViewEngine bve = new BooViewEngine();
string viewPath = Path.Combine(ConfigurationManager.AppSettings["tests.src"], "Views");
bve.Service(new ViewSourceLoaderServiceProvider(viewPath));
bve.Initialize();
StringWriter sw = new StringWriter();
DummyController controller = new DummyController();
controller.PropertyBag = dictionary;
PrepareController(controller, "", "home", "index");
bve.Process(sw, Context, controller, templatePath);
return sw.ToString();
}
public void AddMailTemplateRendered_Expect_A_Copy_Of_Properties()
{
controller = new DummyController();
PrepareController(controller);
controller.Context.Services.EmailTemplateService = new StubEmailTemplateService((StubEngineContext)controller.Context);
var templateName = "welcome";
controller.PropertyBag["Value"] = "One";
controller.RenderMailMessage(templateName, null, controller.PropertyBag);
controller.PropertyBag["Value"] = "Two";
controller.RenderMailMessage(templateName, null, controller.PropertyBag);
Assert.AreEqual(RenderedEmailTemplates[0].Parameters["Value"], "One");
Assert.AreEqual(RenderedEmailTemplates[1].Parameters["Value"], "Two");
}
public Stream GenerateOutput(dynamic shape)
{
var controller = new DummyController(_hca.Current().Request.RequestContext);
using (var stream = new MemoryStream())
using (var streamWriter = new StreamWriter(stream))
{
var originalContext = controller.ControllerContext.HttpContext;
try
{
// Get the Request and User objects from the current, unchanged context
var currentRequest = HttpContext.Current.ApplicationInstance.Context.Request;
var currentUser = HttpContext.Current.ApplicationInstance.Context.User;
// Create our new HttpResponse object containing our HtmlTextWriter
var newResponse = new HttpResponse(streamWriter);
// Create a new HttpContext object using our new Response object and the existing Request and User objects
var newContext = new HttpContextWrapper(
new HttpContext(currentRequest, newResponse)
{
User = currentUser
});
// Swap in our new HttpContext object - output from this controller is now going to our HtmlTextWriter object
controller.ControllerContext.HttpContext = newContext;
new ShapePartialResult(controller, shape).ExecuteResult(controller.ControllerContext);
newResponse.Flush();
streamWriter.Flush();
stream.Flush();
// New stream so everything else here can be disposed
var responseStream = new MemoryStream();
stream.Position = 0;
stream.CopyTo(responseStream);
responseStream.Position = 0;
return responseStream;
}
finally
{
// Setting context back to original so nothing gets messed up
controller.ControllerContext.HttpContext = originalContext;
}
}
}
public void SetupTest() {
StartTest();
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
}
public void SetupTest() {
StartTest();
Surface = GetConfiguredContainer().Resolve<IFrameworkFacade>();
NakedObjectsFramework = ((dynamic)Surface).Framework;
MessageBroker = NakedObjectsFramework.MessageBroker;
controller = new DummyController();
mocks = new ContextMocks(controller);
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-GB");
SetUser("sven");
SetupViewData(new object());
}
public void SetupTest() {
InitializeNakedObjectsFramework(this);
StartTest();
RunFixturesOnce();
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
SetupViewData();
}
public void Start()
{
//check if any dummy controllers need to be created to satisfy the CaptureStream
foreach (var recorder in _Recorders)
{
if (this.StateResolver.Find(recorder.Guid) == null)
{
var dummyController = new DummyController(recorder.Guid);
this.StateResolver.Add(dummyController);
_DummyControllers.Add(dummyController);
}
}
CaptureStream = new CaptureStream(this.Stream, System.IO.FileAccess.Write, this.StateResolver);
lock (_Lock)
{
var maxDelay = TimeSpan.Zero;
foreach (var recorder in _Recorders)
{
var start = DateTime.Now;
recorder.Start();
var delay = DateTime.Now.Subtract(start);
if (delay > maxDelay)
{
maxDelay = delay;
}
}
_OffsetDelay = maxDelay;
}
this.IsStarted = true;
}
public void SetupTest() {
InitializeNakedObjectsFramework(this);
RunFixturesOnce();
StartTest();
Surface = GetConfiguredContainer().Resolve<IFrameworkFacade>();
NakedObjectsFramework = ((dynamic)Surface).Framework;
MessageBroker = NakedObjectsFramework.MessageBroker;
controller = new DummyController();
mocks = new ContextMocks(controller);
SetUser("sven");
SetupViewData();
}
