public void HandleSubscribe_ThrowsEmailAlreadyTakenException_WhenEmailIsAlreadyTaken()
{
//Arrange
SubscribeCommand command = new SubscribeCommand(
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <string>(),
"*****@*****.**",
fixture.Create <string>()
);
CancellationToken token = new CancellationToken();
userReadRepository.GetByEmail(Arg.Is(command.Email)).Returns(
new Budget.Users.Domain.ReadModel.User(
Guid.NewGuid(),
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <DateTime>()
)
);
//Act
Assert.ThrowsAsync <UsernameAlreadyTakenException>(() => handler.Handle(command, token));
//Assert
}
public void SubscribeCommandReceiveAndForgetTest()
{
var subscribeCommand = new SubscribeCommand("receiveandforget");
Assert.IsTrue(subscribeCommand.IsValid);
Assert.AreEqual(SubscriptionType.ReceiveAndForget, subscribeCommand.SubscriptionType);
}
public void Subscribe_ReturnsStatus201_WhenSusbcriptionWorks()
{
//Arrange
SubscribeCommand command = fixture.Create <SubscribeCommand>();
//Act
Task <ActionResult> task = controller.Subscribe(command);
task.Wait();
ActionResult response = task.Result;
//Assert
mediator.Received(1).Send(Arg.Is(command));
response.Should().NotBeNull();
response.Should().BeOfType <CreatedAtRouteResult>();
CreatedAtRouteResult result = response as CreatedAtRouteResult;
result.StatusCode.Should().Be(StatusCodes.Status201Created);
result.Value.Should().NotBeNull();
result.Value.Should().BeOfType <GetUserByUserNameRequest>();
GetUserByUserNameRequest resultValue = result.Value as GetUserByUserNameRequest;
resultValue.UserName.Should().Be(command.UserName);
}
public async Task UserData_Information_SubscriptionTests()
{
//ensure users with no subscriptions don't error out
var noSubUserName = "******";
TestDataInitializer.CreateUser(noSubUserName);
var userData = new Domain.UserData(noSubUserName);
//var userData = new Domain.UserData(noSubUserName);
Assert.AreEqual(0, userData.SubverseSubscriptions.Count());
Assert.AreEqual(false, userData.HasSubscriptions());
Assert.AreEqual(false, userData.HasSubscriptions(DomainType.Subverse));
//test subscription
var subUserName = "******";
TestDataInitializer.CreateUser(subUserName);
var user = TestHelper.SetPrincipal(subUserName);
var cmd = new SubscribeCommand(new DomainReference(DomainType.Subverse, SUBVERSES.Unit), Domain.Models.SubscriptionAction.Subscribe).SetUserContext(user);
var x = await cmd.Execute();
VoatAssert.IsValid(x);
userData = new Domain.UserData(subUserName);
Assert.AreEqual(1, userData.SubverseSubscriptions.Count());
Assert.AreEqual(SUBVERSES.Unit, userData.SubverseSubscriptions.First());
Assert.AreEqual(true, userData.HasSubscriptions());
Assert.AreEqual(true, userData.HasSubscriptions(DomainType.Subverse));
Assert.AreEqual(true, userData.IsUserSubverseSubscriber(SUBVERSES.Unit));
}
public void SubscribeCommandPeekAndCommitTest()
{
var subscribeCommand = new SubscribeCommand("peekandcommit");
Assert.IsTrue(subscribeCommand.IsValid);
Assert.AreEqual(SubscriptionType.PeekAndCommit, subscribeCommand.SubscriptionType);
}
public async Task CreateSet_Test()
{
var userName = "******";
var user = TestHelper.SetPrincipal(userName);
var set = new Set()
{
Name = "HolyHell", Title = "Some Title", Type = SetType.Normal, UserName = userName
};
var cmd = new UpdateSetCommand(set).SetUserContext(user);
var result = await cmd.Execute();
VoatAssert.IsValid(result);
Assert.AreNotEqual(0, result.Response.ID);
var setID = result.Response.ID;
VerifySubscriber(set, userName, 1);
//Subscribe another user
userName = "******";
user = TestHelper.SetPrincipal(userName);
var subCmd = new SubscribeCommand(new DomainReference(DomainType.Set, set.Name, set.UserName), SubscriptionAction.Subscribe).SetUserContext(user);
var subResult = await subCmd.Execute();
VoatAssert.IsValid(result);
VerifySubscriber(set, userName, 2);
//unsub user
subCmd = new SubscribeCommand(new DomainReference(DomainType.Set, set.Name, set.UserName), SubscriptionAction.Unsubscribe).SetUserContext(user);
subResult = await subCmd.Execute();
VoatAssert.IsValid(result);
VerifySubscriber(set, userName, 1, false);
}
public async Task <ActionResult> Subscribe([FromBody] SubscribeCommand subscription)
{
ActionResult response = new StatusCodeResult(StatusCodes.Status422UnprocessableEntity);
try
{
await mediator.Send(subscription);
var request = new GetUserByUserNameRequest(subscription.UserName);
response = CreatedAtRoute("GetUserByUserName", request, request);
}
catch (UserApplicationException ex) when(ex is UsernameAlreadyTakenException || ex is EmailAlreadyTakenException)
{
response = Conflict(ex.Message);
}
catch (Exception ex) when(ex is FormatException || ex is ArgumentException || ex is ArgumentNullException)
{
response = BadRequest();
}
catch
{
response = new StatusCodeResult(StatusCodes.Status500InternalServerError);
}
return(response);
}
private void HandleSubscribeCommand(SubscribeCommand subscribeCommand)
{
if (!_connection.ConnectionState.HasFlag(ConnectionState.LoggedIn))
{
_connection.Reply("subscribe unauthorized");
return;
}
if (_connection.ConnectionState.HasFlag(ConnectionState.Subscribed))
{
_connection.Reply("subscribe already");
_connection.Heartbeat();
return;
}
if (!Enum.IsDefined(typeof(SubscriptionType), subscribeCommand.SubscriptionType) || subscribeCommand.SubscriptionType == SubscriptionType.None)
{
_connection.Reply("subscribe badcommand");
return;
}
_connectionRegistry.PromoteToSubscribedConnection(_connection.DeviceId, subscribeCommand.SubscriptionType);
_connection.Reply("subscribe ack");
_connection.Heartbeat();
}
public void HandleSubscribe_CreatesUser_ThenSavesItAndPublishesEvents()
{
//Arrange
SubscribeCommand command = new SubscribeCommand(
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <string>(),
"*****@*****.**",
fixture.Create <string>()
);
CancellationToken token = new CancellationToken();
//Act
Task task = handler.Handle(command, token);
task.Wait();
//Assert
cryptService.Received(1).Crypt(Arg.Is(command.Password)); //Called by the factory
writeModelUnitOfWork.Received(1).BeginTransaction();
writeModelUnitOfWork.Received(1).Commit();
userWriteRepository.Received(1).Save(Arg.Is <User>(u =>
u.UserName == command.UserName &&
u.FirstName == command.FirstName &&
u.LastName == command.LastName &&
u.Email.Address == command.Email
));
eventPublisher.Received(1).PublishNewEvents(Arg.Is <User>(u => u.UserName == command.UserName));
}
public void Subscribe <TValue>(Action <string> action)
{
var key = typeof(TValue);
var state = _subscriberState.GetOrAdd(key, k => new SubscriberState());
var command = new SubscribeCommand(state, action);
_processor.ExecuteAndForget(key, command);
}
public virtual void ProcessSubscribeCommand(SubscribeCommand cmd)
{
this.Session.AppendResponse(
new ServerStatusResponse(cmd.Tag,
ServerStatusResponseType.NO,
"SUBSCRIBE State Error")
);
}
public override void ProcessSubscribeCommand(SubscribeCommand cmd)
{
this.Session.AppendResponse(
new ServerStatusResponse(cmd.Tag,
ServerStatusResponseType.NO,
"SUBSCRIBE is unsupportted yet")
);
}
private void RaiseCommandExecutes()
{
StopPriceSourceCommand.RaiseCanExecuteChanged();
StartPriceSourceCommand.RaiseCanExecuteChanged();
SubscribeCommand.RaiseCanExecuteChanged();
UnsubscribeCommand.RaiseCanExecuteChanged();
SubscribeAllCommand.RaiseCanExecuteChanged();
UnsubscribeAllCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Подписка на оповещение по типу сообщения для сокета
/// </summary>
/// <param name="webSocket"></param>
/// <param name="command"></param>
public void SubscribeMessage(WebSocket webSocket, SubscribeCommand command)
{
if (!_connectionSockets.TryGetValue(webSocket, out var messageTypes))
{
return;
}
messageTypes.Add(command.MessageType);
}
public async Task <JsonResult> Subscribe(Domain.Models.DomainType domainType, string name, Domain.Models.SubscriptionAction subscribeAction)
{
var domainReference = Domain.Models.DomainReference.Parse(name, domainType);
var cmd = new SubscribeCommand(domainReference, subscribeAction).SetUserContext(User);
var result = await cmd.Execute();
return(JsonResult(result));
}
private async void OnUnsubscribeCommand()
{
canSubscribe = true;
SubscribeCommand.RaiseCanExecuteChanged();
canUnsubscribe = false;
UnsubscribeCommand.RaiseCanExecuteChanged();
await hub.Invoke <int>("Unsubscribe", new object[] { ClientId });
if (connection.State == ConnectionState.Connected)
{
connection.Stop();
}
}
public async void SubscribeBook_Fail(Guid bookId, string bookName, Guid userId)
{
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(a => a.SaveAsync());
var addBookCommandHandler = new SubscribeCommandHandler(_repositoryMock, mockUnitOfWork.Object);
var addBookCommand = new SubscribeCommand
{
BookId = bookId,
BookName = bookName,
UserId = userId
};
await Assert.ThrowsAsync <ValidateException>(() => addBookCommandHandler.HandleAsync(addBookCommand));
}
public void WhenSubscribingItChecksPrefixOfMessageFilter(string filter, string destination, Type message)
{
MessageSinkStub sink = new MessageSinkStub();
RouteManager.AddRoute(filter, destination);
// Act
Service.Subscribe(message, sink);
// Assert
Assert.AreEqual(destination, sink.LastDestination.Name);
Assert.IsInstanceOf <SubscribeCommand>(sink.LastMessage.Body);
SubscribeCommand sc = (SubscribeCommand)sink.LastMessage.Body;
Assert.AreEqual(message.AssemblyQualifiedName, sc.SubscribedMessagesTypeName);
}
public void ItCanHandleSubscribeMessage()
{
// Arrange
SubscriptionMessageHandlers handlers = new SubscriptionMessageHandlers {
SubscriptionService = Service
};
SubscribeCommand cmd = new SubscribeCommand(typeof(MessageToSubscribe1), "WhollyBob");
// Act
handlers.Handle(cmd);
// Assert
IList <QueueName> subscribers = Service.GetSubscribers(typeof(MessageToSubscribe1)).ToList();
Assert.AreEqual(1, subscribers.Count);
Assert.AreEqual(new QueueName("WhollyBob"), subscribers[0]);
}
public async Task <JsonResult> UnSubscribe(string subverseName)
{
//var loggedInUser = User.Identity.Name;
//Voat.Utilities.UserHelper.UnSubscribeFromSubverse(loggedInUser, subverseName);
//return Json("Unsubscribe request was successful." /* CORE_PORT: Removed , JsonRequestBehavior.AllowGet */);
var cmd = new SubscribeCommand(new Domain.Models.DomainReference(Domain.Models.DomainType.Subverse, subverseName), Domain.Models.SubscriptionAction.Unsubscribe).SetUserContext(User);
var r = await cmd.Execute();
if (r.Success)
{
return(Json("Unsubscribe request was successful." /* CORE_PORT: Removed , JsonRequestBehavior.AllowGet */));
}
else
{
return(Json(r.Message /* CORE_PORT: Removed , JsonRequestBehavior.AllowGet */));
}
}
public async Task <Result <SubscriptionDto> > Handle(SubscribeCommand command, CancellationToken cancellationToken)
{
var subscription = await _context.Subscriptions.Include(x => x.Subreddit)
.FirstOrDefaultAsync(subscription => subscription.SubredditId == command.SubredditId && subscription.Sort == command.Sort, cancellationToken);
if (subscription == null)
{
subscription = _mapper.Map <Subscription>(command);
await _context.Subscriptions.AddAsync(subscription, cancellationToken);
subscription.Subreddit = await _context.Subreddits.FirstOrDefaultAsync(x => x.Id == command.SubredditId, cancellationToken);
}
var textChannel = await _context.GuildChannels.Include(x => x.ChannelSubscriptions).FirstOrDefaultAsync(guildChannel => guildChannel.Id == command.ChannelId, cancellationToken);
if (textChannel == null)
{
throw new ArgumentNullException(nameof(textChannel));
}
if (textChannel.ChannelSubscriptions.Any(channelSubscripiton => channelSubscripiton.SubscriptionId == subscription.Id))
{
return(await Result <SubscriptionDto> .FailAsync("Already subscribed!"));
}
var guild = await _context.Guilds.Include(x => x.GuildSetting).Include(x => x.GuildChannels).ThenInclude(x => x.ChannelSubscriptions).FirstOrDefaultAsync(x => x.Id == textChannel.GuildId, cancellationToken);
var count = guild.GuildChannels.SelectMany(x => x.ChannelSubscriptions).Count();
if (count >= guild.GuildSetting.MaxSubscriptions)
{
return(await Result <SubscriptionDto> .FailAsync("Max subscriptions reached"));
}
await _context.ChannelSubscriptions.AddAsync(new ChannelSubscription
{
GuildChannelId = command.ChannelId,
SubscriptionId = subscription.Id,
}, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(await _mediator.Send(new GetSubscriptionByIdQuery(subscription.Id)));
}
public void Constructor_AssignsProperties()
{
//Arrange
string userName = fixture.Create <string>();
string firstName = fixture.Create <string>();
string lastName = fixture.Create <string>();
string email = fixture.Create <string>();
string password = fixture.Create <string>();
//Act
SubscribeCommand command = new SubscribeCommand(userName, firstName, lastName, email, password);
//Assert
command.UserName.Should().Be(userName);
command.FirstName.Should().Be(firstName);
command.LastName.Should().Be(lastName);
command.Email.Should().Be(email);
command.Password.Should().Be(password);
}
public void WhenSubscribingItFollowsMatchingRoutes()
{
// Arrange
MessageSinkStub sink = new MessageSinkStub();
RouteManager.AddRoute("Xyperico.Agres.Tests.MessageBus", "Trilian");
RouteManager.AddRoute("Rofl.abc", "Max");
// Act
Service.Subscribe(typeof(MessageToSubscribe1), sink);
// Assert
Assert.AreEqual("Trilian", sink.LastDestination.Name);
Assert.IsInstanceOf <SubscribeCommand>(sink.LastMessage.Body);
SubscribeCommand sc = (SubscribeCommand)sink.LastMessage.Body;
Assert.AreEqual(MyQueueName.Name, sc.SubscriberQueueName);
Assert.AreEqual(typeof(MessageToSubscribe1).AssemblyQualifiedName, sc.SubscribedMessagesTypeName);
}
public void Subscribe_ReturnsBadRequest_WhenArgumentNullExceptionOccurs()
{
//Arrange
SubscribeCommand command = fixture.Create <SubscribeCommand>();
mediator.When(
m => m.Send(Arg.Is(command))
).Do(args => throw new ArgumentNullException());
//Act
Task <ActionResult> task = controller.Subscribe(command);
task.Wait();
ActionResult response = task.Result;
//Assert
response.Should().NotBeNull();
response.Should().BeOfType <BadRequestResult>();
}
public void HandleSubscribe_RollbacksTransaction_WhenExceptionOccur()
{
//Arrange
SubscribeCommand command = new SubscribeCommand(
fixture.Create <string>(),
fixture.Create <string>(),
fixture.Create <string>(),
"wololoo",
fixture.Create <string>()
);
CancellationToken token = new CancellationToken();
//Act
handler.Handle(command, token);
//Assert
writeModelUnitOfWork.Received(1).BeginTransaction();
writeModelUnitOfWork.Received(1).Rollback();
}
public async Task <IActionResult> SubscribeCommand([FromBody] SubscribeDto value, [FromHeader] Guid userId)
{
_logger.LogInformation("Subscribe for user:{0}, bookid:{1} ", userId, value.BookId);
var book = await _client.GetRequest(new BookDto(), $"{_options.Value.CatalogueUrl}{_options.Value.BookQueryPath}{value.BookId}");
if (book == null)
{
throw new InvalidDataException("book provided does not exist");
}
var command = new SubscribeCommand
{
BookId = value.BookId,
BookName = book.Name,
UserId = userId
};
await _mediator.DispatchAsync(command);
_logger.LogInformation("Subscribed for user:{0}, bookid:{1} ", userId, value.BookId);
return(Ok());
}
public void Subscribe_ReturnsConflict_WhenEmailAlreadyTaken()
{
//Arrange
SubscribeCommand command = fixture.Create <SubscribeCommand>();
mediator.When(
m => m.Send(Arg.Is(command))
).Do(args => throw new EmailAlreadyTakenException());
//Act
Task <ActionResult> task = controller.Subscribe(command);
task.Wait();
ActionResult response = task.Result;
//Assert
response.Should().NotBeNull();
response.Should().BeOfType <ConflictObjectResult>();
}
public async void SubscribeBook_Success()
{
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(a => a.SaveAsync());
var commandHandler = new SubscribeCommandHandler(_repositoryMock, mockUnitOfWork.Object);
var command = new SubscribeCommand
{
BookId = Guid.NewGuid(),
BookName = "Test 1",
UserId = Guid.NewGuid()
};
await commandHandler.HandleAsync(command);
var dbCheck = _repositoryMock as MockBookRepository <Domain.Entities.Subscription>;
Assert.Single(dbCheck.Table);
Assert.Contains(dbCheck.Table.Values, a => a.UserId == command.UserId && a.BookId == command.BookId && a.BookName == command.BookName);
}
private async void OnSubscribeCommand()
{
canSubscribe = false;
SubscribeCommand.RaiseCanExecuteChanged();
canUnsubscribe = true;
UnsubscribeCommand.RaiseCanExecuteChanged();
if (connection.State != ConnectionState.Connected)
{
await connection.Start();
}
try
{
await hub.Invoke <int>("Subscribe", new object[] { ClientId });
}
catch (Exception ex)
{
Message = ex.Message;
}
}
public async Task <IActionResult> OnGet()
{
if (TempData.Peek <UserRegistration>("UserRegistration") == null)
{
await _mediator.Send(new ThrowAlertCommand(AlertType.DANGER, $"An Error Has Occurred", "An error has occurred during user onboarding. Please contact support."));
return(RedirectToPage("~/Error"));
}
var subscriptionReg = TempData.Get <UserRegistration>("UserRegistration");
if (subscriptionReg == null)
{
await _mediator.Send(new ThrowAlertCommand(AlertType.DANGER, "Registration issue", "There was an issue with setting up your subscription."));
return(RedirectToPage("/Account/Register"));
}
Instructor = await _mediator.Send(new GetAppProfileByIdQuery(subscriptionReg.InstructorId));
// check if provided id is an instructor
if (Instructor.IsInstructor())
{
// get subscriptions
SubscriptionOptions = await _mediator.Send(new GetInstructorSubscriptionsQuery(subscriptionReg.InstructorId));
Data = new SubscribeCommand {
InstructorId = Instructor.Id,
ProfileId = subscriptionReg.ProfileId
};
return(Page());
}
else
{
// redirect to default registration page
await _mediator.Send(new ThrowAlertCommand(AlertType.WARNING, "Instructor Not Found", "There is no instructor that matches the instructor Id provided."));
return(RedirectToPage("/Account/Register"));
}
}