public void Host_not_started_exception_thrown_when_getting_uri()
{
var fakeService = new FakeService();
Assert.Throws <Exception>(delegate { var _ = fakeService.Uri; }, "Service not started");
fakeService.Stop();
}
//Lagrer Id på knappen som ble trykket i kommunerId.
//Konverterer så til int for å legge inn som parameter i GetKommuneById, lagres i "kommuner"
//Naviger til KommunePage som svarer til "kommune"
public void Button_Click(object sender, RoutedEventArgs e)
{
var kommunerId = ((Button)sender).Tag;
var kommune = FakeService.GetKommuneById((int)kommunerId);
this.Frame.Navigate(typeof(KommunePage), kommune);
}
public void Work()
{
var flow = FakeService.GetFlow();
this.EventSender.SendEvent(flow);
this.EventSender = this.EventSender.Open();
}
public void Can_add_instance_services()
{
var instance = new FakeService();
AddServiceInstanceTest(m => m.TryAddSingleton <IFakeService>(instance), instance);
AddServiceInstanceTest(m => m.TryAddSingleton(typeof(IFakeService), instance), instance);
}
static void StaticFile(string fileName)
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var sourceFile = new FileInfo(fileName);
fakeService.AddResponse($"/Files/{fileName}", Method.GET, Response.WithStaticFile(fileName));
var httpResponseMessage = httpClient.GetAsync($"/Files/{fileName}").Result;
Expect.equal(httpResponseMessage.StatusCode, HttpStatusCode.OK, "OK is returned");
var destinationFileName = Path.GetTempFileName();
using (var fileStream = new FileStream(destinationFileName, FileMode.Create, FileAccess.Write, FileShare.None)
{
Position = 0
})
{
httpResponseMessage.Content.CopyToAsync(fileStream).Wait();
}
var destinationFile = new FileInfo(destinationFileName);
Expect.isTrue(destinationFile.Exists, "File exists");
Expect.equal(sourceFile.Length, destinationFile.Length, "File lengths are the same");
}
}
public async Task OwinConfigureServiceProviderAddsServices()
{
var list = new List <CreateMiddleware>();
AddMiddleware build = list.Add;
IServiceProvider serviceProvider = null;
FakeService fakeService = null;
var builder = build.UseBuilder(applicationBuilder =>
{
serviceProvider = applicationBuilder.ApplicationServices;
applicationBuilder.Run(context =>
{
fakeService = context.RequestServices.GetService <FakeService>();
return(Task.FromResult(0));
});
},
new ServiceCollection().AddSingleton(new FakeService()).BuildServiceProvider());
list.Reverse();
await list
.Aggregate(notFound, (next, middleware) => middleware(next))
.Invoke(new Dictionary <string, object>());
Assert.NotNull(serviceProvider);
Assert.NotNull(serviceProvider.GetService <FakeService>());
Assert.NotNull(fakeService);
}
public async Task OwinDefaultNullServiceProvider()
{
var list = new List <CreateMiddleware>();
AddMiddleware build = list.Add;
IServiceProvider serviceProvider = null;
FakeService fakeService = null;
bool builderExecuted = false;
bool applicationExecuted = false;
var builder = build.UseBuilder(applicationBuilder =>
{
builderExecuted = true;
serviceProvider = applicationBuilder.ApplicationServices;
applicationBuilder.Run(context =>
{
applicationExecuted = true;
fakeService = context.RequestServices.GetService <FakeService>();
return(Task.FromResult(0));
});
});
list.Reverse();
await list
.Aggregate(notFound, (next, middleware) => middleware(next))
.Invoke(new Dictionary <string, object>());
Assert.True(builderExecuted);
Assert.NotNull(serviceProvider);
Assert.True(applicationExecuted);
Assert.Null(fakeService);
}
public async Task CheckValidState_Initialised_DoesNotThrow()
{
var mockService = new FakeService();
await mockService.InitialiseAsync();
mockService.CheckValidState();
}
public void StaticFiles(string fileName)
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var sourceFile = new FileInfo(Path.Combine(AssemblyDirectory, fileName));
fakeService.AddResponse($"/Files/{fileName}", Method.GET, Response.WithStaticFile(sourceFile.FullName));
var httpResponseMessage = httpClient.GetAsync($"/Files/{fileName}").Result;
Assert.That(httpResponseMessage.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var destinationFileName = Path.GetTempFileName();
using (var fileStream = new FileStream(destinationFileName, FileMode.Create, FileAccess.Write, FileShare.None)
{
Position = 0
})
{
httpResponseMessage.Content.CopyToAsync(fileStream).Wait();
}
var destinationFile = new FileInfo(destinationFileName);
Assert.That(destinationFile.Exists);
Assert.That(sourceFile.Length, Is.EqualTo(destinationFile.Length));
}
}
static void Start_App()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.StartApp(app => app.Run(context => Task.FromResult(context.Response.StatusCode = 200)))))
{
Expect.equal(httpClient.GetAsync("/foo").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
}
}
public void BindDifferentTypesTogetherWithOnesThatOnlyReturnResult()
{
IResult res = FakeService.DoDivision(100, 2)
.Bind((x) => FakeService.DoStringStuff(x.ToString()))
.Bind(FakeService.FakeVoidMethod);
Assert.True(res.IsOk);
}
public void BindDifferentTypesTogether()
{
var res = FakeService.DoDivision(100, 2)
.Bind((x) => FakeService.DoStringStuff(x.ToString()));
Assert.True(res.IsOk);
Assert.Equal("*** 50 ***", res.GetSuccess <string>().Value);
}
public void BindMultipleResultsTogetherError()
{
var res = FakeService.DoDivision(10, 2)
.Bind(() => FakeService.DoDivision(20, 0))
.Bind(() => FakeService.DoDivision(4, 2));
Assert.False(res.IsOk);
}
public void WrapAndRetrieveNone()
{
IOption <int> option = FakeService.GetOption(false);
var some = (None <int>)option;
Assert.IsType <None <int> >(option);
}
public void Delete(Person person)
{
if (People.Contains(person))
{
People.Remove(person);
FakeService.Delete(person);
}
}
public void CheckValidState_Disposed_ThrowsObjectDisposedException()
{
var mockService = new FakeService();
mockService.Dispose();
Assert.Throws <InvalidOperationException>(() => mockService.CheckValidState());
}
public void Add(Person person)
{
if (!People.Contains(person))
{
People.Add(person);
FakeService.Write(person);
}
}
public void Delete(Item item)
{
if (Item.Contains(item))
{
Item.Remove(item);
FakeService.Delete(item);
}
}
public void Add(Item item)
{
if (!Item.Contains(item))
{
Item.Add(item);
FakeService.Write(item);
}
}
public void Handles_urls_in_path()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/http://ping/pong", Method.GET, Response.WithStatusCode(200));
Assert.That(httpClient.GetAsync("/foo/http://ping/pong").Result.IsSuccessStatusCode, Is.True);
}
}
public FooController(ILog log, IServiceProvider serviceProvider)
{
var fakeService = new FakeService(serviceProvider);
Thread.Sleep(2500);
_log = log;
_log.Append($"{DateTime.UtcNow}\t{nameof(FooController)}\r\n");
}
public void VoidMethodTypeIsNull()
{
// Arrange.
// Act.
IResult result = FakeService.FakeVoidMethod("test");
// Assert.
Assert.Null((result as Success).GetResultType());
}
public void BindMultipleResultsWithValueTogetherOk()
{
var res = FakeService.DoDivision(200, 2)
.Bind((x) => FakeService.DoDivision(x, 2))
.Bind((x) => FakeService.DoDivision(x, 2));
Assert.True(res.IsOk);
Assert.Equal(25.0, res.GetSuccess <double>().Value);
}
public void BindMultipleResultsWithValueTogetherError()
{
var res = FakeService.DoDivision(100, 2)
.Bind((x) => FakeService.DoDivision((int)x, 0))
.Bind((x) => FakeService.DoDivision((int)x, 2));
Assert.False(res.IsOk);
Assert.IsType <DivideByZeroException>(res.GetError <double>().ExceptionValue);
}
//Knappen med Id blir lagret i fylkeId.
//Konverterer over til int (for parameter), henter alle kommuner med den Id'en og lagres i "kommuner"
//Navigerer til KommuneListPage med kommunene som svarer til spørringen
public void Button_Click(object sender, RoutedEventArgs e)
{
var fylkeId = ((Button)sender).Tag;
var kommuner = FakeService.GetAllKommunerByFylkeId((int)fylkeId);
this.Frame.Navigate(typeof(KommuneListPage), kommuner);
}
public void NotFound()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
Assert.That(httpClient.GetAsync("/boom").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(fakeService.Requests.First().Path, Is.EqualTo("/boom"));
}
}
static void NotFound()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
Expect.equal(httpClient.GetAsync("/boom").Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned");
Expect.equal(fakeService.Requests.First().Path, "/boom", "Path is recorded");
}
}
static void SetPort()
{
using (var fakeService = new FakeService(8080))
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
Expect.equal(httpClient.GetAsync("/foo").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
}
}
public void Handles_urls_in_path()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/http://ping/pong", Method.GET, Response.WithStatusCode(200));
Assert.That(httpClient.GetAsync("/foo/http://ping/pong").Result.IsSuccessStatusCode, Is.True);
}
}
public void WrapAndRetrieveSome()
{
IOption <int> option = FakeService.GetOption(true);
var some = (Some <int>)option;
Assert.IsType <Some <int> >(option);
Assert.Equal(10, some);
}
public void Body()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithBody(200, "foo"));
Assert.That(httpClient.GetStringAsync("/foo").Result, Is.EqualTo("foo"));
Assert.That(fakeService.Requests.First().Method, Is.EqualTo(Method.GET));
}
}
static void Delegate()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test\\?foo=bar", Method.GET, Response.WithDelegate(x => x.Query["foo"].Contains("bar") ? Response.WithStatusCode(200) : Response.WithStatusCode(404)));
Expect.equal(httpClient.GetAsync("/test?foo=bar").Result.StatusCode, HttpStatusCode.OK, "OK is returned");
Expect.equal(httpClient.GetAsync("/test?foo=baz").Result.StatusCode, HttpStatusCode.NotFound, "NotFound is returned");
}
}
public void Headers()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET,
Response.WithHeaders(200, new Dictionary<string, string> {["foo"] = "bar"}));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
}
}
public void Delegate()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test?foo=bar", Method.GET,
Response.WithDelegate(
x =>
x.Query["foo"].Contains("bar") ? Response.WithStatusCode(200) : Response.WithStatusCode(404)));
Assert.That(httpClient.GetAsync("/test?foo=bar").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/test?foo=baz").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void File()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resources\\rawresponse.txt");
fakeService.AddResponse("/", Method.GET, Response.WithFile(path));
var result = httpClient.GetAsync("/").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void InjectedAspect_Dependency_ShouldBeCommited()
{
// Arrange
var mockRepository = new MockRepository();
var transactionMock = mockRepository.DynamicMock<ITransaction>();
using (mockRepository.Record())
{
transactionMock.Expect(m => m.Commit()).Repeat.Once();
}
var sut = new FakeService { Transaction = transactionMock };
// Act
sut.Process();
// Assert
transactionMock.VerifyAllExpectations();
}
protected void Handle(FakeEvent e, FakeService service1, FakeService service2)
{
}
public void Handle(FakeEvent e, FakeService service)
{
}
public void Set_port()
{
const int port = 8889;
using (var fakeService = new FakeService(port))
using (var httpClient = new HttpClient { BaseAddress = new Uri($"http://localhost:{port}") })
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.Start();
Assert.That(httpClient.GetAsync("/foo").Result.IsSuccessStatusCode, Is.True);
}
}
private void OnFakeEvent(FakeCommand e, FakeService service)
{
}
protected void Handle(FakeCommand e, FakeService service1, FakeService service2)
{
}
public void Header_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/test", Method.GET, Response.WithHeaders(200, "foo : bar", "bing::bong"));
var result = httpClient.GetAsync("/test").Result;
Assert.That(result.Headers.First().Key, Is.EqualTo("foo"));
Assert.That(result.Headers.First().Value.First(), Is.EqualTo("bar"));
Assert.That(result.Headers.ElementAt(1).Key, Is.EqualTo("bing"));
Assert.That(result.Headers.ElementAt(1).Value.First(), Is.EqualTo(":bong"));
}
}
private void OnFakeEvent(FakeEvent e, FakeService service)
{
}
public void HeadersAndBody()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
const string link = "http://foo/bar";
fakeService.AddResponse("/headers", Method.GET,
Response.WithBodyAndHeaders(200, "body", new Dictionary<string, string> {["Link"] = link}));
httpClient.DefaultRequestHeaders.Add("Foo", "Bar");
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.AreEqual(link, result.Headers.GetValues("Link").Single());
var linkHeader = fakeService.Requests.First().Headers.Single(x => x.Key == "Foo").Value;
Assert.That(linkHeader, Is.EqualTo(new[] {"Bar"}));
}
}
public void Same_path_different_method()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/", Method.HEAD, Response.WithStatusCode(404));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var httpRequestMessage = new HttpRequestMessage {Method = HttpMethod.Head};
Assert.That(httpClient.SendAsync(httpRequestMessage).Result.StatusCode,
Is.EqualTo(HttpStatusCode.NotFound));
}
}
public void Status()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/boom").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(fakeService.Requests.Count, Is.EqualTo(1));
}
}
public void NotFound()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
Assert.That(httpClient.GetAsync("/boom").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(fakeService.Requests.First().Path, Is.EqualTo("/boom"));
}
}
public void Host_not_started_exception_thrown_when_getting_uri()
{
var fakeService = new FakeService();
Assert.Throws<Exception>(delegate { var _ = fakeService.Uri; }, "Service not started");
fakeService.Stop();
}
public void Responses_from_file()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resources\\responses.txt");
fakeService.AddResponsesFromFile(path);
Assert.That(httpClient.GetAsync("/statuscode").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/headers").Result.Headers.First(x => x.Key == "foo").Value.First(), Is.EqualTo("bar"));
Assert.That(httpClient.GetAsync("/headers").Result.Headers.First(x => x.Key == "bing").Value.First(), Is.EqualTo("bong"));
Assert.That(httpClient.GetAsync("/body").Result.Content.ReadAsStringAsync().Result, Is.EqualTo("bodytext"));
Assert.That(httpClient.GetAsync("/bodyandheaders").Result.Content.ReadAsStringAsync().Result, Is.EqualTo("body"));
Assert.That(httpClient.GetAsync("/bodyandheaders").Result.Headers.First(x => x.Key == "foo").Value.First(), Is.EqualTo("bar"));
}
}
public void HeadersAndBody2()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/headers", Method.GET, Response.WithBodyAndHeaders(200, "body", "foo : bar"));
var result = httpClient.GetAsync("/headers").Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(result.Content.ReadAsStringAsync().Result, Is.EqualTo("body"));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void Request_received_event()
{
var autoResetEvent = new AutoResetEvent(false);
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo", Method.GET, Response.WithStatusCode(200));
fakeService.OnRequestReceived(request =>
{
if (request.Path == "/foo")
{
autoResetEvent.Set();
}
});
httpClient.GetAsync("/foo").Result.EnsureSuccessStatusCode();
Assert.That(autoResetEvent.WaitOne(1000), Is.True);
}
}
public void Regex()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/foo/1234", Method.GET, Response.WithStatusCode(200));
fakeService.AddResponse("/foo/[\\d]+/boom?this=that", Method.GET, Response.WithStatusCode(500));
Assert.That(httpClient.GetAsync("/foo/1234/boom?this=that").Result.StatusCode,
Is.EqualTo(HttpStatusCode.InternalServerError));
}
}
public void RawResponse()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/boom", Method.GET, Response.WithRawResponse(Resources.rawResponse));
var result = httpClient.GetAsync("/boom").Result;
var body = result.Content.ReadAsStringAsync().Result;
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var expectedBody = $"Body{Environment.NewLine}Text";
Assert.That(body, Is.EqualTo(expectedBody));
Assert.That(result.Headers.GetValues("foo").First(), Is.EqualTo("bar"));
}
}
public void Handle(FakeCommand command, FakeService service)
{
}
public void Service_can_be_explictly_disposed()
{
var fakeService = new FakeService();
fakeService.Dispose();
}
public void Responses_as_params()
{
using (var fakeService = new FakeService())
using (var httpClient = HttpClient(fakeService.Start()))
{
fakeService.AddResponse("/", Method.GET,
Response.WithResponses(Response.WithStatusCode(200), Response.WithStatusCode(500)));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
Assert.That(httpClient.GetAsync("/").Result.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
}
}
public NventsModuleTests()
{
service = new FakeService();
Events.Service = service;
kernel = new StandardKernel(new NventsModule());
}
