import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Before
public void prepareData() throws IOException {
	persistEntities("csv",
			new Class[] { DelegateOrg.class, ContainerScope.class, CacheCompany.class, CacheUser.class, CacheGroup.class, CacheMembership.class },
			StandardCharsets.UTF_8.name());
	CacheManager.getInstance().getCache("container-scopes").removeAll();

	iamProvider = Mockito.mock(IamProvider.class);
	final IamConfiguration configuration = Mockito.mock(IamConfiguration.class);
	Mockito.when(iamProvider.getConfiguration()).thenReturn(configuration);
	userRepository = Mockito.mock(IUserRepository.class);
	groupRepository = Mockito.mock(IGroupRepository.class);
	companyRepository = Mockito.mock(ICompanyRepository.class);
	Mockito.when(configuration.getUserRepository()).thenReturn(userRepository);
	Mockito.when(configuration.getCompanyRepository()).thenReturn(companyRepository);
	Mockito.when(configuration.getGroupRepository()).thenReturn(groupRepository);
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Before
public void prepareData() throws IOException {
	persistEntities("csv",
			new Class[] { DelegateOrg.class, CacheCompany.class, CacheGroup.class, CacheUser.class, CacheMembership.class },
			StandardCharsets.UTF_8.name());
	iamProvider = Mockito.mock(IamProvider.class);
	final IamConfiguration configuration = Mockito.mock(IamConfiguration.class);
	Mockito.when(iamProvider.getConfiguration()).thenReturn(configuration);
	userRepository = Mockito.mock(IUserRepository.class);
	groupRepository = Mockito.mock(IGroupRepository.class);
	companyRepository = Mockito.mock(ICompanyRepository.class);
	Mockito.when(configuration.getUserRepository()).thenReturn(userRepository);
	Mockito.when(configuration.getCompanyRepository()).thenReturn(companyRepository);
	Mockito.when(configuration.getGroupRepository()).thenReturn(groupRepository);
	resource = new UserOrgResource();
	applicationContext.getAutowireCapableBeanFactory().autowireBean(resource);
	resource.setIamProvider(new IamProvider[] { iamProvider });
	Mockito.when(companyRepository.getTypeName()).thenReturn("company");
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Override
public IamConfiguration getConfiguration(final String node) {
	final IamConfiguration configuration = new IamConfiguration();
	final UserLdapRepository repository = getUserLdapRepositoryInternal(node);
	configuration.setUserRepository(repository);
	configuration.setCompanyRepository(newCompanyLdapRepository(node, repository.getTemplate()));
	configuration.setGroupRepository(newGroupLdapRepository(node, repository.getTemplate()));
	repository.setCompanyRepository((CompanyLdapRepository) configuration.getCompanyRepository());
	repository.setGroupLdapRepository((GroupLdapRepository) configuration.getGroupRepository());
	return configuration;
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Override
@CacheResult(cacheName = "iam-node-configuration")
public IamConfiguration getConfiguration() {
	final String primary = getPrimary();
	return servicePluginLocator.getResourceExpected(primary, IamConfigurationProvider.class)
			.getConfiguration(primary);
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Test
public void getConfiguration() {
	final NodeBasedIamProvider provider = new NodeBasedIamProvider();
	provider.configuration = configuration;
	provider.servicePluginLocator = Mockito.mock(ServicePluginLocator.class);
	final IamConfiguration iamConfiguration = Mockito.mock(IamConfiguration.class);
	final IamConfigurationProvider servicePlugin = Mockito.mock(IamConfigurationProvider.class);
	Mockito.when(servicePlugin.getConfiguration("service:id:ldap:dig")).thenReturn(iamConfiguration);
	Mockito.when(provider.servicePluginLocator.getResourceExpected("service:id:ldap:dig",
			IamConfigurationProvider.class)).thenReturn(servicePlugin);

	Assert.assertSame(iamConfiguration, provider.getConfiguration());
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Test
public void toSimpleUserUnknown() {
	final ConfluencePluginResource resource = new ConfluencePluginResource();
	resource.iamProvider = new IamProvider[] { Mockito.mock(IamProvider.class) };
	final IamConfiguration iamConfiguration = Mockito.mock(IamConfiguration.class);
	Mockito.when(resource.iamProvider[0].getConfiguration()).thenReturn(iamConfiguration);
	Mockito.when(iamConfiguration.getUserRepository()).thenReturn(Mockito.mock(IUserRepository.class));
	final SimpleUser simpleUser = resource.toSimpleUser("some", "Some People");
	Assert.assertEquals("some", simpleUser.getId());
	Assert.assertEquals("Some People", simpleUser.getFirstName());
	Assert.assertNull(simpleUser.getLastName());
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Before
public void prepareData() throws IOException {
	// Only with Spring context
	persistEntities("csv", new Class[] { SystemConfiguration.class }, StandardCharsets.UTF_8.name());

	resource = new SaltedAuthenticationResource();
	applicationContext.getAutowireCapableBeanFactory().autowireBean(resource);
	resource.iamProvider = new IamProvider[] { Mockito.mock(IamProvider.class) };
	final IamConfiguration configuration = Mockito.mock(IamConfiguration.class);
	Mockito.when(resource.iamProvider[0].getConfiguration()).thenReturn(configuration);
	userRepository = Mockito.mock(IUserRepository.class);
	Mockito.when(configuration.getUserRepository()).thenReturn(userRepository);
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Override
@CacheResult(cacheName = "iam-ldap-configuration")
public IamConfiguration getConfiguration() {
	return resource.getConfiguration("service:id:ldap:dig");
}
 

import org.ligoj.app.iam.IamConfiguration; //导入依赖的package包/类
@Before
public void init() {
	companyRepository = Mockito.mock(CompanyLdapRepository.class);
	groupRepository = Mockito.mock(GroupLdapRepository.class);
	userRepository = Mockito.mock(UserLdapRepository.class);
	iamProvider = Mockito.mock(IamProvider.class);
	final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class);
	SpringUtils.setSharedApplicationContext(applicationContext);
	final IamConfiguration iamConfiguration = new IamConfiguration();
	iamConfiguration.setCompanyRepository(companyRepository);
	iamConfiguration.setGroupRepository(groupRepository);
	iamConfiguration.setUserRepository(userRepository);
	Mockito.when(iamProvider.getConfiguration()).thenReturn(iamConfiguration);

	companies = new HashMap<>();
	companies.put("company", new CompanyOrg("dnc", "Company"));
	groups = new HashMap<>();
	final Set<String> members = new HashSet<>();
	members.add("u");
	groupLdap = new GroupOrg("dn", "Group", members);
	groups.put("group", groupLdap);
	groupLdap2 = new GroupOrg("dn2", "Group2", new HashSet<>());
	groups.put("group2", groupLdap2);
	user = new UserOrg();
	user.setId("u");
	user.setFirstName("f");
	user.setLastName("l");
	user.setCompany("company");
	final List<String> userGroups = new ArrayList<>();
	userGroups.add("group");
	user.setGroups(userGroups);
	user.setMails(Collections.singletonList("mail"));
	user2 = new UserOrg();
	user2.setId("u2");
	user2.setFirstName("f");
	user2.setLastName("l");
	user2.setCompany("company");
	user2.setGroups(new ArrayList<>());
	users = new HashMap<>();
	users.put("u", user);
	users.put("u2", user2);
	Mockito.when(companyRepository.findAllNoCache()).thenReturn(companies);
	Mockito.when(groupRepository.findAllNoCache()).thenReturn(groups);
	Mockito.when(userRepository.findAllNoCache(groups)).thenReturn(users);
	Mockito.when(companyRepository.findAll()).thenReturn(companies);
	Mockito.when(groupRepository.findAll()).thenReturn(groups);
	Mockito.when(userRepository.findAll()).thenReturn(users);
	CacheManager.getInstance().getCache("ldap").removeAll();
	
	repository = new LdapCacheRepository();
	repository.iamProvider = new IamProvider[] { iamProvider };
	repository.ldapCacheDao = Mockito.mock(LdapCacheDao.class);
}