public void UserRegister_WordsAddedToWordsListForUser()
{
InMemoryUserRepository userRepository = new InMemoryUserRepository();
UserService userService = new UserService(userRepository);
Assert.IsTrue(userRepository.LoadUser(userService.RegisterUser("Test2")).GetWordsListForUser()._wordsInList.FirstOrDefault().Value.CountOfTrueAnswers.ToString().Equals("0"));
}
public void ShouldSuccessfullyRegisterPlayerWithValidData()
{
var transactionFactoryMock = new Mock<ITransactionFactory>();
var playersRepository = new InMemoryUserRepository();
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
playersRepository.Add(new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus"));
var sessionMock = new Mock<ISession>();
var registrationService = new RegistrationService(transactionFactoryMock.Object, uowFactory);
var response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 24,
Huid = "HUID123",
Password = "******",
PushUri = "",
Sex = true,
Comments = "Comments",
Country = "Russia",
Name = "John",
});
Assert.AreEqual(RegistrationResponseType.Success, response.Result);
}
public void ShouldNotAuthenticateBannedPlayers()
{
var playersRepository = new InMemoryUserRepository();
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
var moderator = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus");
moderator.GrantModeratorship();
var player = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus");
playersRepository.Add(player);
player.Ban(moderator);
var sessionMock = new Mock<ISession>();
var transactionFactoryMock = new Mock<ITransactionFactory>();
var authService = new AuthenticationService(Mock.Of<ISettings>(), transactionFactoryMock.Object, uowFactory);
var response = authService.Authenticate(sessionMock.Object,
new AuthenticationRequest
{
Name = "Egor",
Password = "******",
Huid = "111111",
});
Assert.AreEqual(AuthenticationResponseType.Banned, response.Result);
}
public void ShouldGetDetailsForUser()
{
var sessionManager = new SessionManagerMock();
var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice");
var playersRepository = new InMemoryUserRepository();
playersRepository.Add(aliceSessionMock.Object.User);
var egorPlayer = new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus");
egorPlayer.GetType().GetProperty("Id").SetValue(egorPlayer, 5);
playersRepository.Add(egorPlayer);
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
var searchService = new UsersSearchService(uowFactory, Mock.Of<ITransactionFactory>());
var response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { Name = "Egor" });
Assert.AreEqual("Egor", response.User.Name);
response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { Name = "Egorko" });
Assert.IsNull(response.User);
response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = 0 });
Assert.IsNull(response.User);
response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = 0 });
Assert.IsNull(response.User);
response = searchService.GetUserDetails(aliceSessionMock.Object, new GetUserDetailsRequest { UserId = egorPlayer.Id });
Assert.IsNotNull(response.User);
}
public void DevoicedPeopleAreNotAllowedToChat()
{
var sessionManager = new SessionManagerMock();
var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice");
var bobSessionMock = sessionManager.AppendPlayerAsSession("Bob");
var playerRepo = new InMemoryUserRepository();
playerRepo.Add(aliceSessionMock.Object.User);
playerRepo.Add(bobSessionMock.Object.User);
//grant moderatorship to Bob
bobSessionMock.Object.User.GrantModeratorship();
var uowFactory = new UnitOfWorkFactoryMock(playerRepo, Mock.Of<IPublicMessageRepository>());
var chatService = new ChatService(sessionManager, Mock.Of<ISettings>(), null, Mock.Of<ITransactionFactory>(), uowFactory, Mock.Of<IPushNotificator>());
//Alice sends a message - everything is ok
chatService.PublicMessage(aliceSessionMock.Object, new PublicMessageRequest {Body = "F&ck you!"});
//Make sure Bob has received the message
bobSessionMock.Verify(i => i.Send(It.Is<PublicMessageDto>(msg => msg.Body == "F&ck you!")), Times.Once());
//Bob devoices Alice because of foul language
chatService.Devoice(bobSessionMock.Object, new DevoiceRequest { Reason = "Foul language", TargetUserId = aliceSessionMock.Object.User.Id});
bobSessionMock.Verify(i => i.Send(It.Is<DevoiceResponse>(response => response.Result == DevoiceResponseType.Success)), Times.Once());
//Alice doesn't beleave that she is devoiced and tries to send a message
chatService.PublicMessage(aliceSessionMock.Object, new PublicMessageRequest { Body = "Am I really devoiced?" });
//Make sure Bob hasn't receive the message
bobSessionMock.Verify(i => i.Send(It.Is<PublicMessageDto>(msg => msg.Body == "Am I really devoiced?")), Times.Never());
//Server will send a system message notifying User that he is devoiced.
}
public void TestAlreadyExists()
{
var userFactory = new InMemoryUserFactory();
var userRepository = new InMemoryUserRepository();
var userService = new UserService(userRepository);
var userApplicationService = new UserApplicationService(userFactory, userRepository, userService);
var userName = "******";
userRepository.Save(new User(
new UserId("test-id"),
new UserName(userName),
UserType.Normal
));
bool exceptionOccured = false;
try
{
var command = new UserRegisterCommand(userName);
userApplicationService.Register(command);
}
catch
{
exceptionOccured = true;
}
Assert.IsTrue(exceptionOccured);
}
public void RegisterUser_UserAddToList()
{
InMemoryUserRepository userRepository = new InMemoryUserRepository();
UserService userService = new UserService(userRepository);
Assert.AreNotEqual(userRepository.LoadUser(userService.RegisterUser("Test1")), null);
}
public override Task OnDisconnected(bool stopCalled)
{
var inMemoryRepository = new InMemoryUserRepository();
inMemoryRepository.Remove(Guid.Parse(Context.ConnectionId));
return(base.OnDisconnected(stopCalled));
}
public void Setup()
{
//ToDo: create your own in-memory data for testing
//Right now I am using the existing in-memory data
var userRepository = new InMemoryUserRepository();
_userService = new Services.UserService(userRepository);
}
public async Task ShouldNotRegisterIfEmailAlreadyExist()
{
var command = new RegisterCommand("abc", "username", "password", "*****@*****.**");
var repo = new InMemoryUserRepository(new User("abc", "username2", "*****@*****.**", "password", new DateTime(2021, 9, 22)));
var record = await Record.ExceptionAsync(() => RegisterUser(command, repo, new MD5HashPassword()));
AssertThatThrowEmailAlreadyExistsException(record);
}
/// <summary>
/// Adds services which fulfil the various data repository contracts for the application
/// </summary>
public static IServiceCollection AddAppDataRepositories(this IServiceCollection services)
{
var userRepository = new InMemoryUserRepository();
var accountRepository = new InMemoryBankAccountRepository();
return(services
.AddSingleton <IUserRepository>(userRepository)
.AddSingleton <IBankAccountRepository>(accountRepository));
}
public static void DeleteAll()
{
Deleporter.Run(
() =>
{
IUserRepository repository = new InMemoryUserRepository();
DeleporterMvcUtils.TemporarilyReplaceBinding(repository);
});
}
public void GetUserByIdHandlesUserNotFound()
{
const int requestedUserId = 1;
var repository = new InMemoryUserRepository();
var locatedUser = repository.GetUserById(requestedUserId);
Assert.That(locatedUser, Is.Null);
}
static void Main(string[] args)
{
var userRepository = new InMemoryUserRepository();
// オブジェクトを再構築する際にディープコピーを行わないと
var user = userRepository.Find(new UserName("Naruse"));
// 次の操作がリポジトリ内部で保管されているインスタンスにまで影響する
user.ChangeUserName(new UserName("naruse"));
}
private async Task <string> RegisterUser(RegisterCommand command,
InMemoryUserRepository inMemoryUserRepository = null,
MD5HashPassword hashPassword = null)
{
return(await new RegisterCommandHandler(inMemoryUserRepository ?? userRepository,
fakeDateTimeProvider,
hashPassword,
inMemoryTokenGenerator)
.Handle(command, default));
}
static void Main(string[] args)
{
var userRepository = new InMemoryUserRepository();
// 객체를 복원할 때 깊은 복사를 하지 않으면
var user = userRepository.Find(new UserName("John"));
// 복원된 객체에 대한 조작이 리포지토리에 저장된 객체에도 영향을 미친다
user.ChangeUserName(new UserName("john"));
}
public void GetUserByUsernameHandlesUserNotFound()
{
const string requestedUsername = "******";
var repository = new InMemoryUserRepository();
var locatedUser = repository.GetUserByUsername(requestedUsername);
Assert.That(locatedUser, Is.Null);
}
public static async Task Main(string[] args)
{
//
// Setup configuration
IConfiguration configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
//
// Setup application services + feature management
IServiceCollection services = new ServiceCollection();
services.AddSingleton(configuration)
.AddFeatureManagement()
.AddFeatureFilter <ContextualTargetingFilter>();
IUserRepository userRepository = new InMemoryUserRepository();
//
// Get the feature manager from application services
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
IFeatureManager featureManager = serviceProvider.GetRequiredService <IFeatureManager>();
//
// We'll simulate a task to run on behalf of each known user
// To do this we enumerate all the users in our user repository
IEnumerable <string> userIds = InMemoryUserRepository.Users.Select(u => u.Id);
//
// Mimic work items in a task-driven console application
foreach (string userId in userIds)
{
const string FeatureName = "Beta";
//
// Get user
User user = await userRepository.GetUser(userId);
//
// Check if feature enabled
TargetingContext targetingContext = new TargetingContext
{
UserId = user.Id,
Groups = user.Groups
};
bool enabled = await featureManager.IsEnabledAsync(FeatureName, targetingContext);
//
// Output results
Console.WriteLine($"The {FeatureName} feature is {(enabled ? "enabled" : "disabled")} for the user '{userId}'.");
}
}
}
static void Main(string[] args)
{
var userRepository = new InMemoryUserRepository();
var user = new User(new UserName("John"));
// 여기서 인스턴스를 바로 리포지토리에 저장하면
userRepository.Save(user);
// 인스턴스에 대한 조작이 리포지토리에 저장된 객체에도 영향을 미친다
user.ChangeUserName(new UserName("john"));
}
public void UnexaminedWords_CountWordListShouldBeEqualFive()
{
InMemoryUserRepository userRepository = new InMemoryUserRepository();
UserService userService = new UserService(userRepository);
userService.RegisterUser("Test8");
ViewerService viewerService = new ViewerService(userService.LogIn("Test8"), new InMemoryWordRepository());
var wordsListUnexamined = viewerService.ViewUnexaminedWords();
Assert.IsTrue(wordsListUnexamined.Count == 5);
}
static void Main(string[] args)
{
var userRepository = new InMemoryUserRepository();
var user = new User(new UserName("Naruse"));
// ここでインスタンスをそのままリポジトリに保存してしまうと
userRepository.Save(user);
// インスタンスの操作がリポジトリに保存したインスタンスにまで影響する
user.ChangeUserName(new UserName("naruse"));
}
public void GetUserByIdCanLocateUser()
{
const string username = "******";
var repository = new InMemoryUserRepository();
var createdUser = repository.CreateUser(username);
var locatedUser = repository.GetUserById(createdUser.Id);
Assert.That(createdUser, Is.EqualTo(locatedUser));
}
public void SendMessageToUser(string userId, string message)
{
var signalRPublisher = new SignalRPublisher();
var inMemoryRepository = new InMemoryUserRepository();
var currentUser = inMemoryRepository.Get(Guid.Parse(Context.ConnectionId));
var toUser = inMemoryRepository.Get(Guid.Parse(userId));
signalRPublisher.Send(currentUser.Id, BuildChatReceived(currentUser, toUser, message));
signalRPublisher.Send(toUser.Id, BuildChatReceived(currentUser, toUser, message));
}
public void TestRegister()
{
var repository = new InMemoryUserRepository();
var app = new UserApplicationService(repository);
app.RegisterUser("ttaro", "taro", "tanaka");
var user = repository.Find(new UserName("ttaro"));
Assert.IsNotNull(user);
Assert.IsFalse(user.Id.Value == "1");
}
public void CreateUserCanAddUser()
{
const string username = "******";
var repository = new InMemoryUserRepository();
var createdUser = repository.CreateUser(username);
Assert.That(createdUser, Is.Not.Null);
Assert.That(createdUser.Id, Is.GreaterThan(0));
Assert.That(createdUser.Username, Is.EqualTo(username));
}
public void InMemoryUserRepository_GetUserByEmailNonExistant_True()
{
IUserRepository userRepo = new InMemoryUserRepository();
var user1 = userRepo.GetAsync("*****@*****.**");
Assert.IsNotNull(user1);
Assert.AreEqual(user1.Result.Email, "*****@*****.**");
Assert.AreEqual(user1.Result.Password, "secret1");
Assert.AreEqual(user1.Result.Salt, "salt");
Assert.AreEqual(user1.Result.Username, "user1");
}
public void CreateUserGeneratesUniqueIds()
{
const string username1 = "TestUser1";
const string username2 = "TestUser2";
var repository = new InMemoryUserRepository();
var createdUser1 = repository.CreateUser(username1);
var createdUser2 = repository.CreateUser(username2);
Assert.That(createdUser1.Id, Is.Not.EqualTo(createdUser2.Id));
}
public void CreateUserRejectsDuplicateUsername()
{
const string username = "******";
var repository = new InMemoryUserRepository();
repository.CreateUser(username);
Assert.Throws <InvalidOperationException>(
() => repository.CreateUser(username)
);
}
public void SubscribeUser(string nickName)
{
var signalRPublisher = new SignalRPublisher();
var inMemoryRepository = new InMemoryUserRepository();
inMemoryRepository.Add(new User
{
Id = Guid.Parse(Context.ConnectionId),
NickName = nickName
});
signalRPublisher.Publish(new UserSubscribed(Guid.Parse(Context.ConnectionId), nickName));
}
public async Task ShouldCreateUser()
{
var token = "token";
var command = new RegisterCommand("username", "*****@*****.**", "passwordUsername");
var presenter = new RegisterTestPresenter();
var userRepository = new InMemoryUserRepository(token);
var hashPassword = new FakeHashPassword();
var handler = new RegisterCommandHandler(presenter, userRepository, hashPassword);
await handler.Handle(command);
Assert.Equal(token, presenter.Token);
}
public async Task when_adding_new_user_it_should_be_added_correctly_to_the_lists()
{
//Arrange
var user = new User(Guid.NewGuid(), "user", "test", "*****@*****.**", "secret", "salt");
IUserRepository repository = new InMemoryUserRepository();
//Act
await repository.AddAsync(user);
//Assert
var existingUser = await repository.GetAsync(user.Id);
Assert.Equal(user, existingUser);
}
public void EqualWords_CheckShouldBeTrue()
{
InMemoryUserRepository userRepository = new InMemoryUserRepository();
UserService userService = new UserService(userRepository);
userService.RegisterUser("Test4");
ExamineService examineService = new ExamineService(userService.LogIn("Test4"), new InMemoryWordRepository());
var twoWords = examineService.GetTwoWords();
twoWords[1].WordInEnglish = twoWords[0].WordInEnglish;
Assert.IsTrue(examineService.Check(true, twoWords));
}
public async Task ShouldNotCreateUserIfEmailAlreadyExists()
{
var command = new RegisterCommand("username", "*****@*****.**", "passwordUsername");
var presenter = new RegisterTestPresenter();
var userRepository = new InMemoryUserRepository("token", new List <User> {
new User("login", command.Email, command.Password)
});
var hashPassword = new FakeHashPassword();
var handler = new RegisterCommandHandler(presenter, userRepository, hashPassword);
await handler.Handle(command);
Assert.Null(presenter.Token);
}
public void UserRegister_UserRepositorySave()
{
TrainerService trainerService = new TrainerService();
InMemoryUserRepository userRepositoryFirst = new InMemoryUserRepository();
UserService userServiceFirst = new UserService(userRepositoryFirst);
userServiceFirst.RegisterUser("Test3");
trainerService.SaveMemoryUserRepository(userRepositoryFirst);
InMemoryUserRepository userRepositorySecound = new InMemoryUserRepository();
UserService userServiceSecound = new UserService(userRepositorySecound);
Assert.AreNotEqual(userServiceSecound.LogIn("Test3"), null);
}
public void GetService_RequestingARegisteredType_ReturnsExpectedInstance()
{
// Arrange
var container = ContainerFactory.New();
var expectedInstance = new InMemoryUserRepository();
container.RegisterSingleton<IUserRepository>(expectedInstance);
// Act
var actualInstance = ((IServiceProvider)container).GetService(typeof(IUserRepository));
// Assert
Assert.AreEqual(expectedInstance, actualInstance, "The IServiceProvider.GetService method did " +
"not return the expected instance.");
}
public void GetService_RequestingARegisteredType_ReturnsExpectedInstance()
{
// Arrange
var container = ContainerFactory.New();
var expectedInstance = new InMemoryUserRepository();
container.RegisterSingle <IUserRepository>(expectedInstance);
// Act
var actualInstance = ((IServiceProvider)container).GetService(typeof(IUserRepository));
// Assert
Assert.AreEqual(expectedInstance, actualInstance, "The IServiceProvider.GetService method did " +
"not return the expected instance.");
}
public static void InsertUser(User user)
{
Deleporter.Run(
() =>
{
var inMemoryUserRepository = new InMemoryUserRepository();
//var userToInsert = new User()
// {
// Id = user.Id,
// Name = user.Name,
// PasswordHash = user.PasswordHash,
// UserName = user.UserName
// };
inMemoryUserRepository.Insert(user);
DeleporterMvcUtils.TemporarilyReplaceBinding<IUserRepository>(inMemoryUserRepository);
});
}
public void OnlyModeratorsCanDevoice()
{
var sessionManager = new SessionManagerMock();
var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice");
var bobSessionMock = sessionManager.AppendPlayerAsSession("Bob");
var playerRepo = new InMemoryUserRepository();
playerRepo.Add(aliceSessionMock.Object.User);
playerRepo.Add(bobSessionMock.Object.User);
//neither Bob nor Alice are moderators
var uowFactory = new UnitOfWorkFactoryMock(playerRepo, Mock.Of<IPublicMessageRepository>());
var chatService = new ChatService(sessionManager, Mock.Of<ISettings>(), null, Mock.Of<ITransactionFactory>(), uowFactory, Mock.Of<IPushNotificator>());
chatService.Devoice(bobSessionMock.Object, new DevoiceRequest { Reason = "Just for fun", TargetUserId = aliceSessionMock.Object.User.Id });
bobSessionMock.Verify(i => i.Send(It.Is<DevoiceResponse>(response => response.Result == DevoiceResponseType.Failed)), Times.Once());
}
public void ShouldFindExistedPlayer()
{
var sessionManager = new SessionManagerMock();
var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice");
var playersRepository = new InMemoryUserRepository();
playersRepository.Add(aliceSessionMock.Object.User);
playersRepository.Add(new Domain.Entities.User("Egor", "123", "111111", true, 13, string.Empty, "Belarus"));
playersRepository.Add(new Domain.Entities.User("EgorBo", "123", "111111", true, 13, string.Empty, "Belarus"));
playersRepository.Add(new Domain.Entities.User("EgoBo", "123", "111111", true, 13, string.Empty, "Belarus"));
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
var searchService = new UsersSearchService(uowFactory, Mock.Of<ITransactionFactory>());
var response = searchService.SearchUser(aliceSessionMock.Object, new UsersSearchRequest { QueryString = "egor" });
Assert.AreEqual(2, response.Result.Length);
}
public static void InsertUser(string userName, string password, string name)
{
Deleporter.Run(
() =>
{
IUserRepository repository =
DependencyResolver.Current.GetService<IUserRepository>() as InMemoryUserRepository;
if (repository.IsNull())
{
repository = new InMemoryUserRepository();
DeleporterMvcUtils.TemporarilyReplaceBinding(repository);
}
repository.Insert(new User
{
Name = name,
PasswordHash = password,
UserName = userName
});
});
}
public void EveryoneInChatExceptBusyShouldReceiveTheMessage()
{
var playersRepository = new InMemoryUserRepository();
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
var transactionFactoryMock = new Mock<ITransactionFactory>();
var sessionManager = new SessionManagerMock();
var aliceSessionMock = sessionManager.AppendPlayerAsSession("Alice");
var bobSessionMock = sessionManager.AppendPlayerAsSession("Bob");
var egorSessionMock = sessionManager.AppendPlayerAsSession("Egor");
//var johnSessionMock = sessionManager.AppendPlayerAsSession("John", PlayerState.Dueling);
var chatService = new ChatService(sessionManager, Mock.Of<ISettings>(), null, transactionFactoryMock.Object, uowFactory, Mock.Of<IPushNotificator>());
chatService.PublicMessage(aliceSessionMock.Object, new PublicMessageRequest { Body = "Hi dudes!" });
bobSessionMock.Verify(i => i.Send(It.Is<PublicMessageDto>(msg => msg.Body == "Hi dudes!" && msg.AuthorName == "Alice")), Times.Once());
egorSessionMock.Verify(i => i.Send(It.Is<PublicMessageDto>(msg => msg.Body == "Hi dudes!" && msg.AuthorName == "Alice")), Times.Once());
//John should not receive the message because he is busy (dueling or whatever)
//johnSessionMock.Verify(i => i.Send(It.IsAny<PublicMessageDto>()), Times.Never());
}
public void ShouldntAllowRegisterWithInvalidData()
{
var transactionFactoryMock = new Mock<ITransactionFactory>();
var playersRepository = new InMemoryUserRepository();
var uowFactory = new UnitOfWorkFactoryMock(playersRepository, Mock.Of<IPublicMessageRepository>());
var sessionMock = new Mock<ISession>();
var registrationService = new RegistrationService(transactionFactoryMock.Object, uowFactory);
//trying to register with empty name
var response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "Russia",
Name = "",
Huid = "111",
Password = "******"
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
//trying to register with extremly long name
response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "Russia",
Huid = "111",
Name = string.Join("", Enumerable.Range(1, 1000)),
Password = "******"
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
//trying to register with empty psw
response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "Russia",
Name = "Egor",
Huid = "111",
Password = ""
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
//trying to register with extremly long psw
response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "Russia",
Name = "Egor",
Huid = "111",
Password = string.Join("", Enumerable.Range(1, 1000))
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
//trying to register with empty country
response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "",
Name = "Egor",
Password = "******",
Huid = "111"
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
//trying to register with empty huid
response = registrationService.RegisterNewPlayer(sessionMock.Object,
new RegistrationRequest
{
Age = 20,
Comments = "Comments",
Country = "Belarus",
Name = "Egor",
Password = "******",
Huid = ""
});
Assert.AreEqual(RegistrationResponseType.InvalidData, response.Result);
}
public PongRHub()
{
_userRepository = InMemoryUserRepository.GetInstance();
_roomRepository = InMemoryRoomRepository.GetInstance();
}
