public void MoreBuild()
{
IUserBuilder builder = new UserBuilder().Username("user");
builder.Build();
Assert.Throws <InvalidOperationException>(() => builder.Build());
}
public void UpdateExperienceForMinute(List <ulong> userToUpdate, Database db, HashSet <User> peopleToUpdate, Random r)
{
var updateDate = DateTime.Now;
foreach (var userId in userToUpdate)
{
var exp = db.Users.AsQueryable().Where(e => e.Id == userId).Include(u => u.ExperienceRoleReference).ThenInclude(u => u.RoleReference).FirstOrDefault();
var gainedExp = (ulong)r.Next(Global.XPGainRangeMin, Global.XPGainRangeMax);
if (exp != null)
{
if (exp.XPGainDisabled)
{
continue;
}
exp.XP += gainedExp;
exp.MessageCount += 1;
peopleToUpdate.Add(exp);
exp.Updated = updateDate;
}
else
{
var userBuilder = new UserBuilder(userId).WithMessageCount(1).WithXP(gainedExp);
var user = userBuilder.Build();
db.Users.Add(user);
peopleToUpdate.Add(user);
}
}
}
private void RegisterButton_Click(object sender, RoutedEventArgs e)
{
// Get the Form inputs values:
String username, email, password;
username = RegisterUsername.Text;
email = RegisterEmail.Text;
password = RegisterPassword.Password.ToString();
// Check if any of the value was missed
bool isFormValid = ValidateRegisterForm(username, email, password);
// If Form is valid add new user to database:
if (isFormValid)
{
// Build a new user and add it to the database:
UserBuilder builder = new UserBuilder();
builder.SetEmail(email).SetUsername(username).SetPassword(password);
User newUser = builder.Build();
userRepo.Add(newUser);
userRepo.Save();
MessageBox.Show($"{username} created!");
// Redirect user to the Task Mamanger:
TaskCreation tc = new TaskCreation(newUser);
tc.Show();
this.Close();
}
}
public void TestMethod()
{
UserBuilder userBuilder = new UserBuilder()
.SetUserName("user1");
Assert.IsInstanceOf(typeof(User), userBuilder.Build());
}
private List <User> CreateList()
{
var list = new List <User>();
string[] file = File.ReadAllLines(@"C:\Users\Екатерина\Desktop\data.txt");
for (int i = 0; i < file.Length; i++)
{
if (file[i] == "")
{
continue;
}
string[] parse = file[i].Split(' ');
var user = new UserBuilder();
user.SetFirstName(parse[0]);
user.SetSurname(parse[1], list);
user.SetSex(parse[2]);
user.SetAge(parse[3]);
list.Add(user.Build());
}
return(list);
}
private Reference NewUser(Action <UserBuilder> setUp = null)
{
UserBuilder userBuilder = new UserBuilder();
setUp?.Invoke(userBuilder);
return(userBuilder.Build());
}
public async Task GivenUserExists()
{
_userBuilder
.WithAnyId()
.WithTenant(_aTenantId);
_expectedUser = _userBuilder.Build();
_request.UserId = _userBuilder.Id;
_request.Tenant = _aTenantId;
await _testFixture.ConfigureUserExists(_aTenantId, _userBuilder.Id, _expectedUser);
}
public void ReturnTheCorrectNumberOfAdditionalDataItems()
{
int expectedCount = 255.GetRandom(3);
var builder = new UserBuilder();
for (int i = 0; i < expectedCount; i++)
{
builder.AddAdditionalDataItem(string.Empty.GetRandom(), string.Empty.GetRandom());
}
var actual = builder.Build();
Assert.Equal(expectedCount, actual.AdditionalData.Count());
}
protected override void OnModelCreating(ModelBuilder builder)
{
MessageBuilder.Build(builder);
UserBuilder.Build(builder);
ConversationBuilder.Build(builder);
FriendsRequestBuilder.Build(builder);
MessageBuilder.Build(builder);
UserContactBuilder.Build(builder);
ContactBuilder.Build(builder);
NotificationBuilder.Build(builder);
NotificationTypeBuilder.Build(builder);
ParticipantBuilder.Build(builder);
FileStorageBuilder.Build(builder);
ReadReceiptBuilder.Build(builder);
MemberBuilder.Build(builder);
}
public override void SetUp()
{
base.SetUp();
var roleBuilder = new RoleBuilder();
var userBuidler = new UserBuilder();
roleBuilder.With(r => r.Name, PvPStatics.Permissions_Admin);
roleBuilder.AddUser(userBuidler.Build());
roleBuilder.BuildAndSave();
user = userBuidler.BuildAndSave();
requestHandler = new UserHasRoleRequestHandler(DataContext);
request = new UserHasAnyRoleRequest();
}
public void ShouldReturnsErrorWhenCredentialsAreInvalid()
{
UserLoginRequest request = CreateRequest();
var user = UserBuilder.Build();
userRepository
.Setup(x => x.FindBy(It.IsAny <Email>()))
.Returns(user);
hashingService
.Setup(x => x.Hash(It.IsAny <string>()))
.Returns("any-other-hash");
var result = command.Execute(request);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(result.Error, LoginError.InvalidCredentials);
}
public void NormalBuild()
{
IUserBuilder builder = new UserBuilder();
builder.Username("user")
.HashedPassword("pass")
.WinCount(1)
.DrawCount(2)
.LostCount(3);
IUser u = builder.Build();
Assert.Equal("user", u.Username);
Assert.Equal("pass", u.HashedPassword);
Assert.Equal(1, u.WinCount);
Assert.Equal(2, u.DrawCount);
Assert.Equal(3, u.LostCount);
}
private static IUser CreateUser(bool withGroup = false, int[] startContentIds = null, int[] startMediaIds = null)
{
UserBuilder <object> builder = new UserBuilder()
.WithStartContentIds(startContentIds ?? (new int[0]))
.WithStartMediaIds(startMediaIds ?? (new int[0]));
if (withGroup)
{
builder = (UserBuilder)builder
.AddUserGroup()
.WithName("Test")
.WithAlias("test")
.Done();
}
return(builder.Build());
}
private IUser CreateUser(int id = 0, int?startContentId = null, bool withUserGroup = true)
{
UserBuilder <object> builder = new UserBuilder()
.WithId(id)
.WithStartContentIds(startContentId.HasValue ? new[] { startContentId.Value } : new int[0]);
if (withUserGroup)
{
builder = builder
.AddUserGroup()
.WithId(1)
.WithName("admin")
.WithAlias("admin")
.Done();
}
return(builder.Build());
}
public override void SetUp()
{
base.SetUp();
var UserStampBuilder = new UserSecurityStampBuilder();
var UserBuilder = new UserBuilder();
UserStampBuilder.AssignToUser(UserBuilder.Build());
testUser = UserBuilder.BuildAndSave();
testUserSecurityStamp = UserStampBuilder.BuildAndSave();
resetSecurityStamp = new ResetSecurityStamp()
{
TargetUserNameId = testUser.Id
};
handler = new ResetSecurityStampHandler(DataContext);
}
public void ShouldLoginUser()
{
UserLoginRequest request = CreateRequest();
var hashedPassword = "******";
var user = UserBuilder.Build(email: request.Email.Value, password: hashedPassword);
userRepository
.Setup(x => x.FindBy(request.Email))
.Returns(user);
var passwordIntent = request.Password.Value + user.Password.SaltProp.Value;
hashingService
.Setup(x => x.Hash(passwordIntent))
.Returns(hashedPassword);
var result = command.Execute(request);
Assert.IsTrue(result.IsValid);
}
/// <summary>
/// Cria um objeto <see cref="IExtendedPrincipal"/>, com base no <see cref="ISimpleAppUser"/>
/// passado. Dificilmente será necessário sobrecrever esse método.
/// </summary>
protected virtual IExtendedPrincipal CriaIPrincipal(ISimpleAppUser user, bool autenticado)
{
if (user == null)
{
return(null);
}
var bld = new UserBuilder(user.Id, autenticado, user.Name)
{
Login = user.Login
};
if (user.Roles != null)
{
foreach (IAppRole role in user.Roles)
#pragma warning disable 618,612
{
foreach (IAppPermission p in role.Permissions)
{
bld.AddPermission(role.Name, Permission.SetPermission(p.Id, p.Name));
}
}
#pragma warning restore 618,612
}
IExtendedPrincipal u = bld.Build();
if (user.Roles != null)
{
foreach (IAppRole role in user.Roles)
{
#pragma warning disable 618,612
if (role != null && role.Profile != null)
{
u.Properties["skin"] = role.Profile.Skin;
u.Properties["home"] = role.Profile.Home;
}
#pragma warning restore 618,612
}
}
return(u);
}
public void ReturnTheCorrectValueForAnAdditionalDataItemKey()
{
var expectedKey = string.Empty.GetRandom();
var expectedValue = string.Empty.GetRandom();
var builder = new UserBuilder();
for (int i = 0; i < 10.GetRandom(3); i++)
{
builder.AddAdditionalDataItem(string.Empty.GetRandom(), string.Empty.GetRandom());
}
builder.AddAdditionalDataItem(expectedKey, expectedValue);
for (int i = 0; i < 10.GetRandom(3); i++)
{
builder.AddAdditionalDataItem(string.Empty.GetRandom(), string.Empty.GetRandom());
}
var actual = builder.Build();
var result = actual.AdditionalData.Where(d => d.Key == expectedKey).Single();
Assert.Equal(expectedValue, result.Value);
}
public override void SetUp()
{
base.SetUp();
// unsure if this test fixture should include the internal handlers
// as the validator has no clue about *how* the property is validated.
// on the other hand, there isn't much of a better way to test a validator
// than to do a kind of sort of integration test
var token = new CancellationToken();
Task <bool> ReturnCall <TRequest, TRequestHandler>(CallInfo call)
where TRequest : IRequest <bool>
where TRequestHandler : IRequestHandler <TRequest, bool>
{
if (call.Args().Length > 0 && call.Args()[0] is TRequest sentRequest)
{
var handler = (TRequestHandler)System.Activator.CreateInstance(typeof(TRequestHandler), DataContext);
return(handler.Handle(sentRequest, token));
}
return(Task.FromResult(false));
}
mediatorMock.Send(Arg.Any <UserHasAnyRoleRequest>()).Returns(ReturnCall <UserHasAnyRoleRequest, UserHasRoleRequestHandler>);
mediatorMock.Send(Arg.Any <IsValidUserRequest>()).Returns(ReturnCall <IsValidUserRequest, IsValidUserRequestHandler>);
var roleBuilder = new RoleBuilder();
var userBuidler = new UserBuilder();
roleBuilder.With(r => r.Name, PvPStatics.Permissions_Admin);
roleBuilder.AddUser(userBuidler.Build());
roleBuilder.BuildAndSave();
adminUser = userBuidler.BuildAndSave();
normalUser = new UserBuilder().BuildAndSave();
request = new ResetSecurityStamp();
}
protected override void OnModelCreating(ModelBuilder builder)
{
UserBuilder.Build(builder);
UserRolesBuilder.Build(builder);
}
public User Build()
{
return(_builder.Build());
}
public async Task <User> Get(string emailAddress)
{
var user = await userDao.Get(emailAddress);
return(userBuilder.Build(user));
}
public async Task GivenUserExists()
{
await _testFixture.ConfigureUserExists(_aTenantId, _expectedUser.Id, _expectedUser.Build());
}
public void NoUsernameTest()
{
IUserBuilder builder = new UserBuilder();
Assert.Throws <InvalidOperationException>(() => builder.Build());
}
