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); }