public ICompletes <string> SeekTo(string id) { string currentId; switch (id) { case EntryReader.Beginning: Rewind(); currentId = ReadCurrentId(); break; case EntryReader.End: EndInternal(); currentId = ReadCurrentId(); break; case EntryReader.Query: currentId = ReadCurrentId(); break; default: To(id); currentId = ReadCurrentId(); break; } return(Completes.WithSuccess(currentId)); }
public void ActionSignatureWithBlankParamNameThrowsException() { var exception = Assert.Throws <ArgumentException>(() => CreateRequestHandler(Method.Get, "/posts/{ }", ParameterResolver.Path <string>(0)) .Handle(postId => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized(postId))))); Assert.Equal("Empty path parameter name for GET /posts/{ }", exception.Message); }
public void HandlerWithOneParam() { var handler = CreateRequestHandler( Method.Get, "/posts/{postId}/comment/{commentId}/user/{userId}/contact/{contactId}", ParameterResolver.Path <string>(0), ParameterResolver.Path <string>(1), ParameterResolver.Path <string>(2), ParameterResolver.Path <string>(3), ParameterResolver.Query("page", 10), ParameterResolver.Query("pageSize", 10)) .Handle((postId, commentId, userId, contactId, page, pageSize) => Completes.WithSuccess(Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized( $"{postId} {commentId}")))); var response = handler .Execute(Request.WithMethod(Method.Get), "my-post", "my-comment", "admin", "c1", 10, 10, Logger).Outcome; Assert.NotNull(handler); Assert.Equal(Method.Get, handler.Method); Assert.Equal("/posts/{postId}/comment/{commentId}/user/{userId}/contact/{contactId}", handler.Path); Assert.Equal(typeof(string), handler.ResolverParam1.ParamClass); Assert.Equal(typeof(string), handler.ResolverParam2.ParamClass); Assert.Equal(typeof(string), handler.ResolverParam3.ParamClass); Assert.Equal(typeof(string), handler.ResolverParam4.ParamClass); AssertResponsesAreEquals(Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized("my-post my-comment")), response); }
public void ExecuteWithRequestAndMappedParameters() { var request = Request.Has(Method.Get) .And("/posts/my-post/comments/my-comment".ToMatchableUri()) .And(Version.Http1_1); var mappedParameters = new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter> { new Action.MappedParameter("string", "my-post"), new Action.MappedParameter("string", "my-comment"), }); var handler = CreateRequestHandler( Method.Get, "/posts/{postId}", ParameterResolver.Path <string>(0)) .Handle(postId => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized( $"{postId}")))); var response = handler.Execute(request, mappedParameters, Logger).Outcome; AssertResponsesAreEquals( Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized("my-post")), response); }
public void ActionWithoutParamNameShouldNotThrowException() { var handler = CreateRequestHandler(Method.Post, "/posts", ParameterResolver.Body <string>()) .Handle(postId => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized(postId)))); Assert.Equal("", handler.ActionSignature); }
public void ChangeContact(string userId, ContactData contactData) { Stage.ActorOf <IUser>(_addressFactory.From(userId)) .AndThenTo(user => user.WithContact(new Contact(contactData.EmailAddress, contactData.TelephoneNumber))) .OtherwiseConsume(noUser => Completes.With(Response.Of(ResponseStatus.NotFound, UserLocation(userId)))) .AndThenConsume(userState => Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized(UserData.From(userState)))); }
public ICompletes <Stream <TEntry> > StreamFor(string streamName, int fromStreamVersion) { var version = fromStreamVersion; if (_snapshotsView.TryGetValue(streamName, out var snapshot)) { if (snapshot.DataVersion > version) { version = snapshot.DataVersion; } else { snapshot = null !; // reading from beyond snapshot } } var entries = new List <BaseEntry>(); if (_streamIndexesView.TryGetValue(streamName, out var versionIndexes)) { while (versionIndexes.TryGetValue(version, out var journalIndex)) { var entry = _journalView[journalIndex]; entries.Add(entry); ++version; } } return(Completes.WithSuccess(new Stream <TEntry>(streamName, version - 1, entries, snapshot))); }
public ICompletes <TEntry> ReadNext() { if (_currentIndex < _journalView.Count) { return(Completes.WithSuccess(_journalView[_currentIndex++])); } return(null !); }
public void UnsubscribeFromStream(string streamName, string id) { if (Publishers.TryGetValue(streamName, out var publisher)) { publisher.Unsubscribe(new SseSubscriber(streamName, new SseClient(Context?.ClientContext))); } Completes?.With(Response.Of(Response.ResponseStatus.Ok)); }
public ICompletes <Response> RequestWith(Request request) { var completes = _configuration.KeepAlive ? Completes.RepeatableUsing <Response>(_configuration.Stage.Scheduler) : Completes.Using <Response>(_configuration.Stage.Scheduler); _consumer.RequestWith(request, completes); return(completes); }
public ICompletes <Response> RequestWith(Request request) { var completes = _configuration.KeepAlive ? Completes.RepeatableUsing <Response>(_configuration.Stage.Scheduler) : Completes.Using <Response>(_configuration.Stage.Scheduler); request.Headers.And(RequestHeader.Connection, _configuration.KeepAlive ? Header.ValueKeepAlive : Header.ValueClose); _consumer.RequestWith(request, completes); return(completes); }
public void ChangeName(string userId, NameData nameData) { Stage.ActorOf <IUser>(_addressFactory.From(userId)) .AndThenTo(user => user.WithName(new Name(nameData.Given, nameData.Family))) .OtherwiseConsume(noUser => Completes.With(Response.Of(ResponseStatus.NotFound, UserLocation(userId)))) .AndThenConsume(userState => { _repository.Save(userState); Completes.With(Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized(UserData.From(userState)))); }); }
public void SimpleHandler() { var handler = new RequestHandler0(Method.Get, "/helloworld") .Handle(() => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Created))); var response = handler.Execute(Request.WithMethod(Method.Get), Logger).Outcome; Assert.NotNull(handler); Assert.Equal(Method.Get, handler.Method); Assert.Equal("/helloworld", handler.Path); AssertResponsesAreEquals(Response.Of(Response.ResponseStatus.Created), response); }
public void QueryUsers() { var users = new List <UserData>(); foreach (var userState in _repository.Users) { users.Add(UserData.From(userState)); } Completes.With(Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized(users))); }
public void ChangeUser(string userId, UserData userData) { if (userId.EndsWith("123")) { Completes.With(Response.Of(ResponseStatus.PermanentRedirect, Headers.Of(ResponseHeader.Of(ResponseHeader.Location, "/")))); } else { Completes.With(Response.Of(ResponseStatus.Ok)); } }
public override ICompletes <IJournalReader?> JournalReader(string name) { IJournalReader?reader = null; if (!_journalReaders.ContainsKey(name)) { reader = new InMemoryJournalReader(_journal, name); _journalReaders.Add(name, reader); } return(Completes.WithSuccess(reader)); }
public void SimpleHandlerWithBinaryResponse() { byte[] body = { 1, 2, 1, 2 }; var handler = new RequestHandler0(Method.Get, "/helloworld") .Handle(() => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Created, Body.From(body, Body.Encoding.None)))); var response = handler.Execute(Request.WithMethod(Method.Get), Logger).Outcome; Assert.NotNull(handler); Assert.Equal(Method.Get, handler.Method); Assert.Equal("/helloworld", handler.Path); Assert.Equal(Body.From(body, Body.Encoding.None).BinaryContent, response.Entity.BinaryContent); }
public void Feed(string feedName, string feedProductId, Type feedProducerClass, int feedProductElements) { var producer = FeedProducer(feedName, feedProducerClass); if (producer == null) { Completes?.With(Response.Of(ResponseStatus.NotFound, $"Feed '{feedName}' does not exist.")); } else { producer.ProduceFeedFor(new FeedProductRequest(Context, feedName, feedProductId, feedProductElements)); } }
public override ICompletes <IJournalReader <TNewEntry>?> JournalReader <TNewEntry>(string name) { IJournalReader <TNewEntry>?reader = null; if (!_journalReaders.ContainsKey(name)) { var entryReader = new InMemoryJournalReader <TEntry>(_journal, name); reader = entryReader as IJournalReader <TNewEntry>; _journalReaders.Add(name, entryReader); } return(Completes.WithSuccess(reader)); }
public void QueryUser(string userId) { var userState = _repository.UserOf(userId); if (userState.DoesNotExist()) { Completes.With(Response.Of(ResponseStatus.NotFound, UserLocation(userId))); } else { Completes.With(Response.Of(ResponseStatus.Ok, JsonSerialization.Serialized(UserData.From(userState)))); } }
/// <summary> /// Completes with <code>Ok</code> and the file content or <code>NotFound</code>. /// </summary> /// <param name="contentFile">The name of the content file to be served</param> /// <param name="root">The root path of the static content</param> /// <param name="validSubPaths">The indicating the valid file paths under the root</param> public void ServeFile(string contentFile, string root, string validSubPaths) { if (string.IsNullOrWhiteSpace(_rootPath)) { var slash = root.EndsWith("/") ? "" : "/"; _rootPath = root + slash; } var uri = string.IsNullOrEmpty(contentFile) ? "/index.html" : Context?.Request?.Uri?.AbsolutePath; var contentPath = ContentFilePath(_rootPath + uri); try { // try to read from disk first if (FileExists(contentFile)) { var fileContent = ReadFile(contentPath); Completes?.With(Response.Of(ResponseStatus.Ok, Body.From(fileContent, Body.Encoding.UTF8).Content)); } else // than from embedded resource { _rootPath = root.EndsWith("/") ? root.Substring(0, root.Length - 1) : root; uri = string.IsNullOrEmpty(contentFile) ? "/index.html" : Context?.Request?.Uri?.AbsolutePath; _assembly ??= LoadFromPath(root); var response = new List <string> { $"{_rootPath}{uri}", $"{WithIndexHtmlAppended(_rootPath + uri)}" } .Select(CleanPath) .Where(IsValidFilename) .Take(1) .Select(FileResponse) .DefaultIfEmpty(NotFound()); Completes?.With(response.First()); } } catch (IOException) { Completes?.With(Response.Of(ResponseStatus.InternalServerError)); } catch (ArgumentException) { Completes?.With(Response.Of(ResponseStatus.NotFound)); } }
internal static ICompletes <Response> ExecuteRequest( Func <ICompletes <Response>?> executeAction, IErrorHandler errorHandler, ILogger logger) { try { return(executeAction.Invoke()? .RecoverFrom(ex => ResourceErrorProcessor.ResourceHandlerError(errorHandler, logger, ex)) !); } catch (Exception ex) { return(Completes.WithFailure(ResourceErrorProcessor.ResourceHandlerError(errorHandler, logger, ex))); } }
public void TestThatAlreadyFailedExecutesOtherwise() { var failureValue = -1; var completes = Completes.WithFailure(100); completes .AndThen(value => value * value) .Otherwise <int>(x => failureValue = x); var outcome = completes.Await(); Assert.True(completes.HasFailed); Assert.Equal(100, outcome); Assert.Equal(100, failureValue); }
public override ICompletes <IStreamReader?> StreamReader(string name) { IStreamReader?reader = null; if (!_journalReaders.ContainsKey(name)) { var castedDictionary = new Dictionary <string, State <T> >(); foreach (var snapshotPair in _snapshots) { castedDictionary.Add(snapshotPair.Key, (State <T>)snapshotPair.Value); } reader = new InMemoryStreamReader <T>(_journal.Cast <BaseEntry>().ToList(), _streamIndexes, castedDictionary, name); _streamReaders.Add(name, reader); } return(Completes.WithSuccess(reader)); }
public void ExecuteWithRequestAndMappedParametersHasToReturnTheSameAsExecute() { var request = Request.Has(Method.Get) .And("/hellworld".ToMatchableUri()) .And(Version.Http1_1); var mappedParameters = new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter>()); var handler = new RequestHandler0(Method.Get, "/helloworld") .Handle(() => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Created))); var response = handler.Execute(request, mappedParameters, Logger).Outcome; Assert.NotNull(handler); Assert.Equal(Method.Get, handler.Method); Assert.Equal("/helloworld", handler.Path); AssertResponsesAreEquals(Response.Of(Response.ResponseStatus.Created), response); }
public void TestThatNestedRecoverFromWithNoExceptionSetsOutput() { var failureValue = -1; var completes = new BasicCompletes <int>(_testScheduler); completes .AndThenTo(42, value => Completes.WithSuccess(value * 2).RecoverFrom(e => 0)) .RecoverFrom(e => failureValue = int.Parse(e.Message)); completes.With(2); completes.Await(); Assert.False(completes.HasFailed); Assert.Equal(-1, failureValue); Assert.Equal(4, completes.Outcome); }
private ICompletes <IOutcome <ArithmeticException, float> > DivZero(float x) { IOutcome <ArithmeticException, float> outcome; var value = x / 0; if (float.IsPositiveInfinity(value)) { outcome = Failure.Of <ArithmeticException, float>(new ArithmeticException("division by zero")); } else { outcome = Success.Of <ArithmeticException, float>(value); } return(Completes.WithSuccess(outcome)); }
internal static ICompletes <Response> ExecuteRequest( Request request, MediaTypeMapper mediaTypeMapper, Func <ICompletes <IObjectResponse> > executeAction, IErrorHandler errorHandler, ILogger logger) { try { return(executeAction.Invoke() .AndThen(objectResponse => ToResponse(objectResponse, request, mediaTypeMapper, errorHandler, logger))); } catch (Exception ex) { return(Completes.WithFailure(ResourceErrorProcessor.ResourceHandlerError(errorHandler, logger, ex))); } }
public ICompletes <IEnumerable <TEntry> > ReadNext(int maximumEntries) { var entries = new List <TEntry>(); for (int count = 0; count < maximumEntries; ++count) { if (_currentIndex < _journalView.Count) { entries.Add(_journalView[_currentIndex++]); } else { break; } } return(Completes.WithSuccess(entries.AsEnumerable())); }
public void ExecuteWithRequestAndMappedParametersWithWrongSignatureType() { var request = Request.Has(Method.Get) .And("/posts/my-post".ToMatchableUri()) .And(Version.Http1_1); var mappedParameters = new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter> { new Action.MappedParameter("String", "my-post") }); var handler = CreateRequestHandler(Method.Get, "/posts/{postId}", ParameterResolver.Path <int>(0)) .Handle(postId => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized("it is my-post")))); var exception = Assert.Throws <ArgumentException>(() => handler.Execute(request, mappedParameters, Logger)); Assert.Equal("Value my-post is of mimeType String instead of Int32", exception.Message); }