public void Can_Change_Session_Variables()
{
Resolve <IMultiTenancyConfig>().IsEnabled = true;
AbpSession.UserId = 1;
AbpSession.TenantId = 42;
var resolvedAbpSession = LocalIocManager.Resolve <IAbpSession>();
resolvedAbpSession.UserId.ShouldBe(1);
resolvedAbpSession.TenantId.ShouldBe(42);
Resolve <IMultiTenancyConfig>().IsEnabled = false;
AbpSession.UserId.ShouldBe(1);
AbpSession.TenantId.ShouldBe(1);
}
public void UpdateComponentDataOfCreator_NoCreator()
{
ReloadDB();
bool isPass = true;
var testAbpSession = (TestAbpSession)Resolve <IAbpSession>();
testAbpSession.UserId = 2;
testAbpSession.TenantId = 1;
try
{
_appService.UpdateComponentDataOfCreator(new IEManageSystem.Services.ManageHome.CMS.Pages.Dto.UpdateComponentDataInput()
{
PageName = "ContentPage1Name",
PageDataName = "PageData1Name",
ComponentDatas = new List <ComponentDataDto>()
{
new ComponentDataDto()
{
Sign = "UpdateComponentData_BaseTest_ContentComponentDataSign",
SingleDatas = new List <SingleComponentDataDto>()
{
new SingleComponentDataDto()
{
Name = "UpdateComponentData_BaseTest_SingleComponentDataName"
}
}
}
}
});
var dbContext = LocalIocManager.Resolve <IEManageSystemDbContext>();
dbContext.SaveChanges();
}
catch (UserFriendlyException)
{
isPass = false;
}
// 还原 AbpSession
ApplyAbpSession();
Assert.True(isPass == false);
}
public RedisCacheManager_Test()
{
LocalIocManager.Register <ICachingConfiguration, CachingConfiguration>();
LocalIocManager.Register <IAbpRedisCacheDatabaseProvider, AbpRedisCacheDatabaseProvider>();
LocalIocManager.Register <ICacheManager, AbpRedisCacheManager>();
LocalIocManager.IocContainer.Register(Component.For <IAbpStartupConfiguration>().UsingFactoryMethod(() => Substitute.For <IAbpStartupConfiguration>()));
var defaultSlidingExpireTime = TimeSpan.FromHours(24);
LocalIocManager.Resolve <ICachingConfiguration>().Configure("MyTestCacheItems", cache =>
{
cache.DefaultSlidingExpireTime = defaultSlidingExpireTime;
});
_cache = LocalIocManager.Resolve <ICacheManager>().GetCache <string, MyCacheItem>("MyTestCacheItems");
_cache.DefaultSlidingExpireTime.ShouldBe(defaultSlidingExpireTime);
}
public MemoryCacheManager_Tests()
{
LocalIocManager.Register <IMSStartupConfiguration, MSStartupConfiguration>();
LocalIocManager.Register <ICachingConfiguration, CachingConfiguration>();
LocalIocManager.Register <ICacheManager, MSMemoryCacheManager>();
LocalIocManager.Register <MyClientPropertyInjects>(DependencyLifeStyle.Transient);
_cacheManager = LocalIocManager.Resolve <ICacheManager>();
var defaultSlidingExpireTime = TimeSpan.FromHours(24);
_cache = _cacheManager.GetCache <string, MyCacheItem>("MyCacheItems");
_otherCache = _cacheManager.GetCache("otherCacheItems");
//_cache.DefaultSlidingExpireTime.ShouldBe(defaultSlidingExpireTime);
}
public RedisCacheManager_Test()
{
LocalIocManager.Register <AbpRedisCacheConfig, AbpRedisCacheConfig>();
LocalIocManager.Register <ICachingConfiguration, CachingConfiguration>();
LocalIocManager.Register <IAbpRedisConnectionProvider, AbpRedisConnectionProvider>();
LocalIocManager.Register <ICacheManager, AbpRedisCacheManager>();
var defaultSlidingExpireTime = TimeSpan.FromHours(24);
LocalIocManager.Resolve <ICachingConfiguration>().Configure("MyCacheItems", cache =>
{
cache.DefaultSlidingExpireTime = defaultSlidingExpireTime;
});
_cache = LocalIocManager.Resolve <ICacheManager>().GetCache <string, MyCacheItem>("MyCacheItems");
_cache.DefaultSlidingExpireTime.ShouldBe(defaultSlidingExpireTime);
}
public void Should_Automatically_Release_Resolved_Dependencies_When_Injected_Class_Released()
{
//Arrange
LocalIocManager.Register <IScopedIocResolver, ScopedIocResolver>(DependencyLifeStyle.Transient);
LocalIocManager.Register <MyDependency>(DependencyLifeStyle.Transient);
LocalIocManager.Register <MyMainClass>(DependencyLifeStyle.Transient);
//Act
var mainClass = LocalIocManager.Resolve <MyMainClass>();
var dependency = mainClass.CreateDependency();
dependency.IsDisposed.ShouldBeFalse();
LocalIocManager.Release(mainClass);
//Assert
dependency.IsDisposed.ShouldBeTrue();
}
public void Should_Get_Same_Objects_For_Singleton_Dependency_When_Registred_By_Basic_Conventional_Registrar()
{
//Arrange
LocalIocManager.AddConventionalRegistrar(new BasicConventionalRegistrar());
//Act
LocalIocManager.RegisterAssemblyByConvention(typeof(TestSingletonDependencyObject).Assembly);
var transientDependencyObject1 = LocalIocManager.Resolve <TestSingletonDependencyObject>();
var transientDependencyObject2 = LocalIocManager.Resolve <TestSingletonDependencyObject>();
//Assert
transientDependencyObject1.ShouldNotBeNull();
transientDependencyObject2.ShouldNotBeNull();
transientDependencyObject1.ShouldBeSameAs(transientDependencyObject2);
}
public void UniqueIdentifierProvider_Should_ReturnConcatKeyWithBothProvider()
{
IUniqueIdentifierProvider cpuBasedProvider = Substitute.For <IUniqueIdentifierProvider, CpuBasedIdentifierProvider>();
IUniqueIdentifierProvider hddBasedProvider = Substitute.For <IUniqueIdentifierProvider, HddBasedIdentifierProvider>();
const string cpuBasedKey = "cpuBasedKey";
const string hddBasedKey = "hddBasedKey";
cpuBasedProvider.Get().Returns(cpuBasedKey);
hddBasedProvider.Get().Returns(hddBasedKey);
// Registration order important!
Register(hddBasedProvider);
Register(cpuBasedProvider);
LocalIocManager.ResolveAll <IUniqueIdentifierProvider>().BuildForAll().ShouldBe(hddBasedKey + cpuBasedKey);
}
public async Task Should_Rollback_If_Uow_Is_Not_Completed()
{
//CreatePersonAsync will use same UOW.
using (var uow = LocalIocManager.Resolve <IUnitOfWorkManager>().Begin())
{
await _personAppService.CreatePersonAsync(new CreatePersonInput { Name = "john" });
//await uow.CompleteAsync(); //It's intentionally removed from code to see roll-back
}
//john will not be added since uow is not completed (so, rolled back)
await UsingDbContext(async context =>
{
(await context.People.CountAsync()).ShouldBe(_initialPeople.Count);
(await context.People.FirstOrDefaultAsync(p => p.Name == "john")).ShouldBe(null);
});
}
protected async Task <T> UsingDbContextAsync <T>(int?tenantId, Func <ShopCartDbContext, Task <T> > func)
{
T result;
using (UsingTenantId(tenantId))
{
using (var context = LocalIocManager.Resolve <ShopCartDbContext>())
{
context.DisableAllFilters();
result = await func(context);
await context.SaveChangesAsync();
}
}
return(result);
}
public async Task Should_Update_Subscription_Async()
{
var subscription = await CreateTestSubscriptionAsync(
AppWebhookDefinitionNames.Test,
AppWebhookDefinitionNames.Users.Created,
AppWebhookDefinitionNames.Theme.DefaultThemeChanged
);
string headerKey = "MyHeaderKey", headerValue = "MyHeaderValue";
subscription.AddWebhookHeader(headerKey, headerValue);
subscription.UnsubscribeWebhook(AppWebhookDefinitionNames.Users.Created);
subscription.WebhookUri = "www.aspnetboilerplate.com";
subscription.Secret = "secret2";
await _webhookSubscriptionsStore.UpdateAsync(subscription);
WebhookSubscriptionInfo sub;
using (var uowManager = LocalIocManager.ResolveAsDisposable <IUnitOfWorkManager>())
{
using (uowManager.Object.Begin())
{
using (uowManager.Object.Current.SetTenantId(AbpSession.TenantId))
{
sub = await _webhookSubscriptionsStore.GetAsync(subscription.Id);
}
}
}
var webhookDefinitionAsList = sub.GetSubscribedWebhooks();
webhookDefinitionAsList.Count.ShouldBe(2);
webhookDefinitionAsList[0].ShouldBe(AppWebhookDefinitionNames.Test);
webhookDefinitionAsList[1].ShouldBe(AppWebhookDefinitionNames.Theme.DefaultThemeChanged);
var additionalHeaderAsDictionary = sub.GetWebhookHeaders();
additionalHeaderAsDictionary.Count.ShouldBe(1);
additionalHeaderAsDictionary.ShouldContainKey(headerKey);
additionalHeaderAsDictionary[headerKey].ShouldBe(headerValue);
sub.WebhookUri.ShouldBe(subscription.WebhookUri);
sub.Secret.ShouldBe(subscription.Secret);
}
public AuthorizationInterceptor_Tests()
{
//SUT: AuthorizationInterceptor and AuthorizeAttributeHelper
LocalIocManager.IocContainer.Register(
Component.For <IFeatureChecker>().Instance(Substitute.For <IFeatureChecker>())
);
LocalIocManager.Register <IAuthorizationConfiguration, AuthorizationConfiguration>();
LocalIocManager.Register <IMultiTenancyConfig, MultiTenancyConfig>();
LocalIocManager.Register <AuthorizationInterceptor>(DependencyLifeStyle.Transient);
LocalIocManager.Register <AbpAsyncDeterminationInterceptor <AuthorizationInterceptor> >(DependencyLifeStyle.Transient);
LocalIocManager.Register <IAuthorizationHelper, AuthorizationHelper>(DependencyLifeStyle.Transient);
LocalIocManager.IocContainer.Register(
Component.For <MyTestClassToBeAuthorized_Sync>().Interceptors <AbpAsyncDeterminationInterceptor <AuthorizationInterceptor> >().LifestyleTransient(),
Component.For <MyTestClassToBeAuthorized_Async>().Interceptors <AbpAsyncDeterminationInterceptor <AuthorizationInterceptor> >().LifestyleTransient(),
Component.For <MyTestClassToBeAllowProtected_Async>().Interceptors <AbpAsyncDeterminationInterceptor <AuthorizationInterceptor> >().LifestyleTransient(),
Component.For <MyTestClassToBeAllowProtected_Sync>().Interceptors <AbpAsyncDeterminationInterceptor <AuthorizationInterceptor> >().LifestyleTransient()
);
//Mock session
var session = Substitute.For <IAbpSession>();
session.TenantId.Returns(1);
session.UserId.Returns(1);
LocalIocManager.IocContainer.Register(Component.For <IAbpSession>().Instance(session));
//Mock permission checker
var permissionChecker = Substitute.For <IPermissionChecker>();
permissionChecker.IsGrantedAsync("Permission1").Returns(true);
permissionChecker.IsGrantedAsync("Permission2").Returns(true);
permissionChecker.IsGrantedAsync("Permission3").Returns(false); //Permission3 is not granted
permissionChecker.IsGranted("Permission1").Returns(true);
permissionChecker.IsGranted("Permission2").Returns(true);
permissionChecker.IsGranted("Permission3").Returns(false); //Permission3 is not granted
LocalIocManager.IocContainer.Register(Component.For <IPermissionChecker>().Instance(permissionChecker));
_syncObj = LocalIocManager.Resolve <MyTestClassToBeAuthorized_Sync>();
_asyncObj = LocalIocManager.Resolve <MyTestClassToBeAuthorized_Async>();
_syncObjForProtectedMethod = LocalIocManager.Resolve <MyTestClassToBeAllowProtected_Sync>();
_asyncObjForProtectedMethod = LocalIocManager.Resolve <MyTestClassToBeAllowProtected_Async>();
}
public void Should_Override_When_Using_IsDefault_Twice()
{
//Arrange
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl1>().LifestyleTransient());
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl2>().LifestyleTransient().IsDefault());
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl3>().LifestyleTransient().IsDefault());
//Act
var service = LocalIocManager.Resolve <IMyService>();
var allServices = LocalIocManager.IocContainer.ResolveAll <IMyService>();
//Assert
Assert.IsInstanceOfType(service, typeof(MyImpl3));
Assert.AreEqual(allServices.Length, 3);
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl1)));
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl2)));
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl3)));
}
private async Task ScheduledJob_Executions()
{
var controller = LocalIocManager.Resolve <DataTableController>();
var input = new DataTableGetDataInput
{
Id = "ScheduledJob_Executions_test",
CurrentPage = 1,
PageSize = int.MaxValue,
};
DataTableData data = null;
await WithUnitOfWorkAsync(async() =>
{
data = await controller.GetTableDataAsync <ScheduledJobExecution, Guid>(input, CancellationToken.None);
});
}
public void Should_Not_Override_As_Default()
{
//Arrange
LocalIocManager.Register <IMyService, MyImpl1>(DependencyLifeStyle.Transient);
LocalIocManager.Register <IMyService, MyImpl2>(DependencyLifeStyle.Transient);
LocalIocManager.Register <IMyService, MyImpl3>(DependencyLifeStyle.Transient);
//Act
var service = LocalIocManager.Resolve <IMyService>();
var allServices = LocalIocManager.IocContainer.ResolveAll <IMyService>();
//Assert
Assert.IsInstanceOfType(service, typeof(MyImpl1));
Assert.AreEqual(allServices.Length, 3);
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl1)));
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl2)));
Assert.IsTrue(allServices.Any(s => s.GetType() == typeof(MyImpl3)));
}
private async Task Fetch_ByTableConfigId()
{
var controller = LocalIocManager.Resolve <DataTableController>();
var input = new DataTableGetDataInput
{
Id = PersonsTableId,
CurrentPage = 1,
PageSize = int.MaxValue,
};
DataTableData data = null;
await WithUnitOfWorkAsync(async() =>
{
data = await controller.GetTableDataAsync <Person, Guid>(input, CancellationToken.None);
});
}
public void AddPageData_BaseTest()
{
ReloadDB();
_appService.AddPageData(new IEManageSystem.Services.ManageHome.CMS.Pages.Dto.AddPageDataInput()
{
PageName = "ContentPage1Name",
Name = "AddPageData_BaseTest_Name",
Title = "AddPageData_BaseTest_Title",
Tags = new List <TagDto>()
});
var dbContext = LocalIocManager.Resolve <IEManageSystemDbContext>();
dbContext.SaveChanges();
Assert.True(dbContext.PageDatas.Any(e => e.Name == "AddPageData_BaseTest_Name"));
}
public async Task Should_Get_User_OrganizationUnit_Roles()
{
var unitOfWorkManager = LocalIocManager.Resolve <IUnitOfWorkManager>();
using (var uow = unitOfWorkManager.Begin())
{
var user = await UserManager.FindByNameAsync("user1");
//Check initial role assignments
var roles = await UserManager.GetRolesAsync(user.Id);
roles.ShouldContain("role1");
roles.ShouldNotContain("role2");
roles.ShouldContain("organizationUnitRole");
await uow.CompleteAsync();
}
}
public void DeletePageData_BaseTest()
{
ReloadDB();
_appService.DeletePageData(new IEManageSystem.Services.ManageHome.CMS.Pages.Dto.DeletePageDataInput()
{
PageName = "ContentPage1Name",
Name = "PageData1Name"
});
var dbContext = LocalIocManager.Resolve <IEManageSystemDbContext>();
dbContext.SaveChanges();
Assert.True(!dbContext.Set <PageData>().Any(e => e.Name == "PageData1Name"));
Assert.True(!dbContext.Set <ContentComponentData>().Any(e => e.Sign == "ContentPage1_Component1Sign"));
Assert.True(!dbContext.Set <SingleComponentData>().Any(e => e.Name == "PageData1_ContentComponentData1_SingleComponentData2Name"));
}
public void GetRoles_StateUnderTest_ExpectedBehavior()
{
// Arrange
var service = this.CreateService();
service.ObjectMapper = LocalIocManager.Resolve <Abp.ObjectMapping.IObjectMapper>();
service.AbpSession = Resolve <IAbpSession>();
LoginAsTenant("Default", "85261586394");
service.UnitOfWorkManager = Resolve <IUnitOfWorkManager>();
service.UnitOfWorkManager.Begin();
// Act
var result = service.GetRoles();
// Assert
Assert.True(result.Status == TaskStatus.RanToCompletion && result.Result.Items.Count > 0);
}
private async Task TestConvert()
{
var controller = LocalIocManager.Resolve <DataTableController>();
var input = new DataTableGetDataInput
{
Id = "Areas_Index",
CurrentPage = 1,
PageSize = int.MaxValue,
};
DataTableData data = null;
await WithUnitOfWorkAsync(async() =>
{
data = await controller.GetTableDataAsync <Area, Guid>(input, CancellationToken.None);
});
}
public async Task ChangePassword_Test()
{
//Act
await _profileAppService.ChangePassword(
new ChangePasswordInput
{
CurrentPassword = "******",
NewPassword = "******"
});
//Assert
var currentUser = await GetCurrentUserAsync();
LocalIocManager
.Resolve <IPasswordHasher <User> >()
.VerifyHashedPassword(currentUser, currentUser.Password, "2mF9d8Ac!5")
.ShouldBe(PasswordVerificationResult.Success);
}
public void AddStaticPage_BaseTest()
{
ReloadDB();
_appService.AddPage(new IEManageSystem.Services.ManageHome.CMS.Pages.Dto.AddPageInput()
{
Name = "AddStaticPage_BaseTest",
Description = "Description1",
DisplayName = "DisplayName1",
PageType = "StaticPage"
});
var dbContext = LocalIocManager.Resolve <IEManageSystemDbContext>();
dbContext.SaveChanges();
Assert.True(dbContext.Pages.Any(e => e.Name == "AddStaticPage_BaseTest"));
}
public void Should_Get_Default_Service()
{
//Arrange
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl1>().LifestyleTransient());
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl2>().LifestyleTransient().IsDefault());
LocalIocManager.IocContainer.Register(Component.For <IMyService>().ImplementedBy <MyImpl3>().LifestyleTransient());
//Act
var service = LocalIocManager.Resolve <IMyService>();
var allServices = LocalIocManager.IocContainer.ResolveAll <IMyService>();
//Assert
service.ShouldBeOfType <MyImpl2>();
allServices.Length.ShouldBe(3);
allServices.Any(s => s.GetType() == typeof(MyImpl1)).ShouldBeTrue();
allServices.Any(s => s.GetType() == typeof(MyImpl2)).ShouldBeTrue();
allServices.Any(s => s.GetType() == typeof(MyImpl3)).ShouldBeTrue();
}
public void Should_Not_Override_As_Default()
{
//Arrange
LocalIocManager.Register <IMyService, MyImpl1>(DependencyLifeStyle.Transient);
LocalIocManager.Register <IMyService, MyImpl2>(DependencyLifeStyle.Transient);
LocalIocManager.Register <IMyService, MyImpl3>(DependencyLifeStyle.Transient);
//Act
var service = LocalIocManager.Resolve <IMyService>();
var allServices = LocalIocManager.IocContainer.ResolveAll <IMyService>();
//Assert
service.ShouldBeOfType <MyImpl1>();
allServices.Length.ShouldBe(3);
allServices.Any(s => s.GetType() == typeof(MyImpl1)).ShouldBeTrue();
allServices.Any(s => s.GetType() == typeof(MyImpl2)).ShouldBeTrue();
allServices.Any(s => s.GetType() == typeof(MyImpl3)).ShouldBeTrue();
}
public async Task Update_User_Basic_Tests()
{
//Arrange
var managerRole = CreateRole("Manager");
var adminUser = await GetUserByUserNameOrNullAsync(User.AdminUserName);
//Act
await UserAppService.CreateOrUpdateUser(
new CreateOrUpdateUserInput
{
User = new UserEditDto
{
Id = adminUser.Id,
EmailAddress = "*****@*****.**",
Name = "System1",
Surname = "Admin2",
Password = "******",
UserName = adminUser.UserName
},
AssignedRoleNames = new[] { "Manager" }
});
//Assert
await UsingDbContextAsync(async context =>
{
//Get created user
var updatedAdminUser = await GetUserByUserNameOrNullAsync(adminUser.UserName, includeRoles: true);
updatedAdminUser.ShouldNotBe(null);
updatedAdminUser.Id.ShouldBe(adminUser.Id);
//Check some properties
updatedAdminUser.EmailAddress.ShouldBe("*****@*****.**");
updatedAdminUser.TenantId.ShouldBe(AbpSession.TenantId);
LocalIocManager
.Resolve <IPasswordHasher <User> >()
.VerifyHashedPassword(updatedAdminUser, updatedAdminUser.Password, "123qwE*")
.ShouldBe(PasswordVerificationResult.Success);
//Check roles
updatedAdminUser.Roles.Count.ShouldBe(1);
updatedAdminUser.Roles.Any(ur => ur.RoleId == managerRole.Id).ShouldBe(true);
});
}
public async Task FullName_Hyphen_Test()
{
var uowManager = LocalIocManager.Resolve <IUnitOfWorkManager>();
using (var uow = uowManager.Begin())
{
var repository = LocalIocManager.Resolve <IRepository <Region, long> >();
var config = new GeneralTreeConfiguration <Region, long>
{
Hyphen = "->"
};
var codeGenerate = new GeneralTreeCodeGenerate(new GeneralTreeCodeGenerateConfiguration());
var manager =
new GeneralTreeManager <Region, long>(codeGenerate, repository, config);
//Act
var beijing = new Region
{
Name = "beijing"
};
await manager.CreateAsync(beijing);
uowManager.Current.SaveChanges();
var xicheng = new Region
{
Name = "xicheng",
ParentId = beijing.Id
};
await manager.CreateAsync(xicheng);
uowManager.Current.SaveChanges();
//Assert
var xc = GetRegion("xicheng");
xc.ShouldNotBeNull();
xc.Name.ShouldBe("xicheng");
xc.FullName.ShouldBe("beijing->xicheng");
uow.Complete();
}
}
public void Should_Success_Circular_Property_Injection_Singleton()
{
Initialize_Test(DependencyLifeStyle.Singleton);
var obj1 = LocalIocManager.Resolve <MyClass1>();
obj1.Obj2.ShouldNotBe(null);
obj1.Obj3.ShouldNotBe(null);
obj1.Obj2.Obj3.ShouldNotBe(null);
var obj2 = LocalIocManager.Resolve <MyClass2>();
obj2.Obj1.ShouldBe(null); //!!!Notice: It's null
obj2.Obj3.ShouldNotBe(null);
MyClass1.CreateCount.ShouldBe(1);
MyClass2.CreateCount.ShouldBe(1);
MyClass3.CreateCount.ShouldBe(1);
}
protected virtual T UsingDbContext <T>(Func <AppDbContext, T> func)
{
T result;
using (var uow = Resolve <IUnitOfWorkManager>().Begin())
{
using (var contextProvider = LocalIocManager.ResolveAsDisposable <IDbContextProvider <AppDbContext> >())
{
var dbContext = contextProvider.Object.GetDbContext();
result = func(dbContext);
dbContext.SaveChanges(true);
}
uow.Complete();
}
return(result);
}
public void Should_Insert_And_Retrieve_User()
{
var useRepository = LocalIocManager.Resolve <IRepository <User, long> >();
useRepository.FirstOrDefault(u => u.EmailAddress == "*****@*****.**").ShouldBe(null);
useRepository.Insert(new User
{
TenantId = null,
UserName = "******",
Name = "System",
Surname = "Administrator",
EmailAddress = "*****@*****.**",
IsEmailConfirmed = true,
Password = "******" //123qwe
});
useRepository.FirstOrDefault(u => u.EmailAddress == "*****@*****.**").ShouldNotBe(null);
}
