- 替换Spring注解（如@Component、@Service、@Configuration等）为自定义注解。 - 实现了SimpleContainer作为轻量级依赖注入容器，替代Spring ApplicationContext。 - 添加了AutowireFactory用于自动装配依赖。 - 实现了ComponentScanner用于扫描和注册组件。 - 添加了BeanDefinition和BeanFactory用于管理Bean元数据和实例化。 - 移除了Spring相关依赖（如spring-context、spring-beans等）。 - 更新了相关类以适配新的依赖注入机制。 - 添加了单元测试和集成测试，验证新容器的功能和兼容性alpha-remove-spring-context
Ling Bao
9 months ago
parent
a697e1c14e
commit
c4434d07e3
@ -0,0 +1,19 @@
|
||||
package com.ultikits.ultitools.utils;
|
||||
import java.lang.annotation.Annotation;
|
||||
|
||||
public class AnnotationUtils {
|
||||
|
||||
private AnnotationUtils() {
|
||||
}
|
||||
|
||||
public static <T extends Annotation> T findAnnotation(Class<?> clazz, Class<T> annotationType) {
|
||||
if (clazz == null) {
|
||||
return null;
|
||||
}
|
||||
T annotation = clazz.getAnnotation(annotationType);
|
||||
if (annotation != null) {
|
||||
return annotation;
|
||||
}
|
||||
return findAnnotation(clazz.getSuperclass(), annotationType);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,172 @@
|
||||
package com.ultikits.ultitools.context;
|
||||
|
||||
import com.ultikits.ultitools.annotations.Autowired;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Unit tests for AutowireFactory class.
|
||||
* <br>
|
||||
* AutowireFactory类的单元测试。
|
||||
*/
|
||||
@DisplayName("AutowireFactory Tests")
|
||||
class AutowireFactoryTest {
|
||||
|
||||
private SimpleContainer container;
|
||||
private AutowireFactory autowireFactory;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
container = new SimpleContainer();
|
||||
autowireFactory = new AutowireFactory(container);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should autowire dependencies")
|
||||
void testAutowireDependencies() {
|
||||
// Given
|
||||
TestRepository testRepository = new TestRepository();
|
||||
|
||||
container.registerType(TestRepository.class, testRepository);
|
||||
|
||||
TestController controller = new TestController();
|
||||
|
||||
// When
|
||||
autowireFactory.autowireBean(controller);
|
||||
|
||||
// Then
|
||||
assertNotNull(controller.getRepository());
|
||||
assertEquals(testRepository, controller.getRepository());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle null dependencies gracefully")
|
||||
void testNullDependencies() {
|
||||
// Given
|
||||
TestController controller = new TestController();
|
||||
// No repository registered
|
||||
|
||||
// When - should not throw exception
|
||||
assertDoesNotThrow(() -> autowireFactory.autowireBean(controller));
|
||||
|
||||
// Then
|
||||
assertNull(controller.getRepository());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should autowire multiple dependencies")
|
||||
void testMultipleDependencies() {
|
||||
// Given
|
||||
TestRepository repository = new TestRepository();
|
||||
TestService service = new TestService();
|
||||
|
||||
container.registerType(TestRepository.class, repository);
|
||||
container.registerType(TestService.class, service);
|
||||
|
||||
TestComplexController controller = new TestComplexController();
|
||||
|
||||
// When
|
||||
autowireFactory.autowireBean(controller);
|
||||
|
||||
// Then
|
||||
assertNotNull(controller.getRepository());
|
||||
assertNotNull(controller.getService());
|
||||
assertEquals(repository, controller.getRepository());
|
||||
assertEquals(service, controller.getService());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should not autowire non-annotated fields")
|
||||
void testNonAnnotatedFields() {
|
||||
// Given
|
||||
TestRepository repository = new TestRepository();
|
||||
container.registerType(TestRepository.class, repository);
|
||||
|
||||
TestNoAutowireController controller = new TestNoAutowireController();
|
||||
|
||||
// When
|
||||
autowireFactory.autowireBean(controller);
|
||||
|
||||
// Then
|
||||
assertNull(controller.getRepository()); // Should remain null
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle inheritance in autowiring")
|
||||
void testInheritanceAutowiring() {
|
||||
// Given
|
||||
TestService service = new TestService();
|
||||
container.registerType(TestService.class, service);
|
||||
|
||||
TestExtendedController controller = new TestExtendedController();
|
||||
|
||||
// When
|
||||
autowireFactory.autowireBean(controller);
|
||||
|
||||
// Then
|
||||
assertNotNull(controller.getService());
|
||||
assertEquals(service, controller.getService());
|
||||
}
|
||||
|
||||
// Test helper classes
|
||||
public static class TestRepository {
|
||||
public String getData() {
|
||||
return "repository data";
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestService {
|
||||
public String process() {
|
||||
return "processed";
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestController {
|
||||
@Autowired
|
||||
private TestRepository repository;
|
||||
|
||||
public TestRepository getRepository() {
|
||||
return repository;
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestComplexController {
|
||||
@Autowired
|
||||
private TestRepository repository;
|
||||
|
||||
@Autowired
|
||||
private TestService service;
|
||||
|
||||
public TestRepository getRepository() {
|
||||
return repository;
|
||||
}
|
||||
|
||||
public TestService getService() {
|
||||
return service;
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestNoAutowireController {
|
||||
private TestRepository repository; // No @Autowired annotation
|
||||
|
||||
public TestRepository getRepository() {
|
||||
return repository;
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestBaseController {
|
||||
@Autowired
|
||||
private TestService service;
|
||||
|
||||
public TestService getService() {
|
||||
return service;
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestExtendedController extends TestBaseController {
|
||||
// Inherits the autowired service field
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,128 @@
|
||||
package com.ultikits.ultitools.context;
|
||||
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Unit tests for BeanFactory class.
|
||||
* <br>
|
||||
* BeanFactory类的单元测试。
|
||||
*/
|
||||
@DisplayName("BeanFactory Tests")
|
||||
class BeanFactoryTest {
|
||||
|
||||
private SimpleContainer container;
|
||||
private BeanFactory beanFactory;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
container = new SimpleContainer();
|
||||
beanFactory = new BeanFactory(container);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should register singleton through factory")
|
||||
void testRegisterSingleton() {
|
||||
// Given
|
||||
String beanName = "testBean";
|
||||
String instance = "Test Instance";
|
||||
|
||||
// When
|
||||
beanFactory.registerSingleton(beanName, instance);
|
||||
|
||||
// Then
|
||||
Object retrievedBean = beanFactory.getBean(beanName);
|
||||
assertNotNull(retrievedBean);
|
||||
assertEquals(instance, retrievedBean);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get bean by name through factory")
|
||||
void testGetBeanByName() {
|
||||
// Given
|
||||
String beanName = "namedBean";
|
||||
String instance = "Named Instance";
|
||||
container.registerSingleton(beanName, instance);
|
||||
|
||||
// When
|
||||
Object result = beanFactory.getBean(beanName);
|
||||
|
||||
// Then
|
||||
assertNotNull(result);
|
||||
assertEquals(instance, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get bean by type through factory")
|
||||
void testGetBeanByType() {
|
||||
// Given
|
||||
String instance = "Typed Instance";
|
||||
container.registerType(String.class, instance);
|
||||
|
||||
// When
|
||||
String result = beanFactory.getBean(String.class);
|
||||
|
||||
// Then
|
||||
assertNotNull(result);
|
||||
assertEquals(instance, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should return null for non-existent bean")
|
||||
void testGetNonExistentBean() {
|
||||
// When
|
||||
Object result = beanFactory.getBean("nonExistent");
|
||||
|
||||
// Then
|
||||
assertNull(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should return null for non-existent type")
|
||||
void testGetNonExistentType() {
|
||||
// When
|
||||
Integer result = beanFactory.getBean(Integer.class);
|
||||
|
||||
// Then
|
||||
assertNull(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should work with complex objects")
|
||||
void testComplexObjects() {
|
||||
// Given
|
||||
TestComplexBean complexBean = new TestComplexBean("test", 42);
|
||||
String beanName = "complexBean";
|
||||
|
||||
// When
|
||||
beanFactory.registerSingleton(beanName, complexBean);
|
||||
TestComplexBean retrieved = (TestComplexBean) beanFactory.getBean(beanName);
|
||||
|
||||
// Then
|
||||
assertNotNull(retrieved);
|
||||
assertEquals("test", retrieved.getName());
|
||||
assertEquals(42, retrieved.getValue());
|
||||
}
|
||||
|
||||
// Test helper class
|
||||
public static class TestComplexBean {
|
||||
private final String name;
|
||||
private final int value;
|
||||
|
||||
public TestComplexBean(String name, int value) {
|
||||
this.name = name;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,97 @@
|
||||
package com.ultikits.ultitools.context;
|
||||
|
||||
import com.ultikits.ultitools.annotations.Component;
|
||||
import com.ultikits.ultitools.annotations.Service;
|
||||
import com.ultikits.ultitools.annotations.Configuration;
|
||||
import com.ultikits.ultitools.annotations.Bean;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Unit tests for ComponentScanner class.
|
||||
* <br>
|
||||
* ComponentScanner类的单元测试。
|
||||
*/
|
||||
@DisplayName("ComponentScanner Tests")
|
||||
class ComponentScannerTest {
|
||||
|
||||
private SimpleContainer container;
|
||||
private ComponentScanner scanner;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
container = new SimpleContainer();
|
||||
scanner = new ComponentScanner(container);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle scanner initialization")
|
||||
void testScannerInitialization() {
|
||||
// Then
|
||||
assertNotNull(scanner);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle empty package scan gracefully")
|
||||
void testEmptyPackageScan() {
|
||||
// When - should not throw exception
|
||||
assertDoesNotThrow(() -> scanner.scanPackage("com.nonexistent.package"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle multiple package scan")
|
||||
void testMultiplePackageScan() {
|
||||
// When - should not throw exception
|
||||
assertDoesNotThrow(() -> scanner.scanPackages(
|
||||
"com.ultikits.ultitools.context",
|
||||
"com.nonexistent.package"
|
||||
));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should register configuration beans properly")
|
||||
void testConfigurationProcessing() {
|
||||
// Given - we'll manually register a configuration since scanning requires class files
|
||||
TestConfiguration config = new TestConfiguration();
|
||||
container.registerSingleton("testConfiguration", config);
|
||||
|
||||
// When
|
||||
container.getBean("testBean", String.class);
|
||||
|
||||
// Then - for now just test that container doesn't break
|
||||
// In real scenario, configuration processing would be tested with actual class files
|
||||
assertNotNull(container);
|
||||
}
|
||||
|
||||
// Test helper classes
|
||||
@Component
|
||||
public static class TestComponent {
|
||||
public String getName() {
|
||||
return "TestComponent";
|
||||
}
|
||||
}
|
||||
|
||||
@Service
|
||||
public static class TestService {
|
||||
public String process() {
|
||||
return "processed";
|
||||
}
|
||||
}
|
||||
|
||||
@Configuration
|
||||
public static class TestConfiguration {
|
||||
|
||||
@Bean
|
||||
public String testBean() {
|
||||
return "Test Bean Value";
|
||||
}
|
||||
|
||||
@Bean
|
||||
public Integer numberBean() {
|
||||
return 42;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,180 @@
|
||||
package com.ultikits.ultitools.context;
|
||||
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestInstance;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Integration tests for the entire context package.
|
||||
* <br>
|
||||
* 整个context包的集成测试。
|
||||
*/
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
@DisplayName("Context Integration Tests")
|
||||
class ContextIntegrationTest {
|
||||
|
||||
private SimpleContainer container;
|
||||
|
||||
@BeforeAll
|
||||
void setUp() {
|
||||
container = new SimpleContainer();
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should integrate SimpleContainer with BeanFactory")
|
||||
void testSimpleContainerWithBeanFactory() {
|
||||
// Given
|
||||
BeanFactory factory = container.getBeanFactory();
|
||||
String testBean = "Integration Test Bean";
|
||||
|
||||
// When
|
||||
factory.registerSingleton("integrationBean", testBean);
|
||||
String retrieved = (String) factory.getBean("integrationBean");
|
||||
|
||||
// Then
|
||||
assertNotNull(retrieved);
|
||||
assertEquals(testBean, retrieved);
|
||||
assertTrue(container.containsBean("integrationBean"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should integrate SimpleContainer with AutowireFactory")
|
||||
void testSimpleContainerWithAutowireFactory() {
|
||||
// Given
|
||||
AutowireFactory autowireFactory = container.getAutowireCapableBeanFactory();
|
||||
TestIntegrationRepository repository = new TestIntegrationRepository();
|
||||
|
||||
container.registerType(TestIntegrationRepository.class, repository);
|
||||
TestIntegrationController controller = new TestIntegrationController();
|
||||
|
||||
// When
|
||||
autowireFactory.autowireBean(controller);
|
||||
|
||||
// Then
|
||||
assertNotNull(controller.getRepository());
|
||||
assertEquals(repository, controller.getRepository());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle full container lifecycle")
|
||||
void testFullContainerLifecycle() {
|
||||
// Given
|
||||
SimpleContainer testContainer = new SimpleContainer();
|
||||
|
||||
// When
|
||||
testContainer.registerSingleton("lifecycleBean", "lifecycle test");
|
||||
testContainer.start();
|
||||
|
||||
// Then
|
||||
assertTrue(testContainer.isRunning());
|
||||
assertNotNull(testContainer.getBean("lifecycleBean"));
|
||||
|
||||
// When
|
||||
testContainer.stop();
|
||||
|
||||
// Then
|
||||
assertFalse(testContainer.isRunning());
|
||||
|
||||
// When
|
||||
testContainer.close();
|
||||
|
||||
// Then
|
||||
assertFalse(testContainer.containsBean("lifecycleBean"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should support complex dependency injection scenarios")
|
||||
void testComplexDependencyInjection() {
|
||||
// Given
|
||||
TestIntegrationRepository repository = new TestIntegrationRepository();
|
||||
TestIntegrationService service = new TestIntegrationService();
|
||||
|
||||
container.registerType(TestIntegrationRepository.class, repository);
|
||||
container.registerType(TestIntegrationService.class, service);
|
||||
container.registerBean(TestIntegrationController.class);
|
||||
|
||||
// When
|
||||
TestIntegrationController controller = container.getBean(TestIntegrationController.class);
|
||||
|
||||
// Then
|
||||
assertNotNull(controller);
|
||||
assertNotNull(controller.getRepository());
|
||||
assertEquals(repository, controller.getRepository());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle bean scopes correctly")
|
||||
void testBeanScopes() {
|
||||
// Given
|
||||
String beanName = "scopeTestBean";
|
||||
String instance = "scope test";
|
||||
|
||||
// When
|
||||
container.registerSingleton(beanName, instance);
|
||||
|
||||
// Then
|
||||
assertTrue(container.isSingleton(beanName));
|
||||
assertFalse(container.isPrototype(beanName));
|
||||
|
||||
// Verify same instance is returned
|
||||
Object first = container.getBean(beanName);
|
||||
Object second = container.getBean(beanName);
|
||||
assertSame(first, second);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should support parent-child container hierarchies")
|
||||
void testParentChildHierarchy() {
|
||||
// Given
|
||||
SimpleContainer parent = new SimpleContainer();
|
||||
parent.registerSingleton("parentBean", "parent value");
|
||||
|
||||
SimpleContainer child = new SimpleContainer(parent);
|
||||
child.registerSingleton("childBean", "child value");
|
||||
|
||||
// When
|
||||
Object parentBean = child.getBean("parentBean");
|
||||
Object childBean = child.getBean("childBean");
|
||||
|
||||
// Then
|
||||
assertNotNull(parentBean);
|
||||
assertNotNull(childBean);
|
||||
assertEquals("parent value", parentBean);
|
||||
assertEquals("child value", childBean);
|
||||
|
||||
// Parent should not see child beans
|
||||
assertNull(parent.getBean("childBean"));
|
||||
}
|
||||
|
||||
// Test helper classes for integration testing
|
||||
public static class TestIntegrationRepository {
|
||||
public String findData() {
|
||||
return "integration data";
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestIntegrationService {
|
||||
public String processData(String data) {
|
||||
return "processed: " + data;
|
||||
}
|
||||
}
|
||||
|
||||
public static class TestIntegrationController {
|
||||
@com.ultikits.ultitools.annotations.Autowired
|
||||
private TestIntegrationRepository repository;
|
||||
|
||||
public TestIntegrationRepository getRepository() {
|
||||
return repository;
|
||||
}
|
||||
|
||||
public String handleRequest() {
|
||||
if (repository != null) {
|
||||
return repository.findData();
|
||||
}
|
||||
return "no data";
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,249 @@
|
||||
package com.ultikits.ultitools.context;
|
||||
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.ValueSource;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Unit tests for SimpleContainer class.
|
||||
* <br>
|
||||
* SimpleContainer类的单元测试。
|
||||
*/
|
||||
@DisplayName("SimpleContainer Tests")
|
||||
class SimpleContainerTest {
|
||||
|
||||
private SimpleContainer container;
|
||||
|
||||
@Mock
|
||||
private BeanPostProcessor mockBeanPostProcessor;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
MockitoAnnotations.openMocks(this);
|
||||
container = new SimpleContainer();
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should register and retrieve singleton bean")
|
||||
void testRegisterAndRetrieveSingleton() {
|
||||
// Given
|
||||
String beanName = "testBean";
|
||||
String beanInstance = "Test Instance";
|
||||
|
||||
// When
|
||||
container.registerSingleton(beanName, beanInstance);
|
||||
Object retrievedBean = container.getBean(beanName);
|
||||
|
||||
// Then
|
||||
assertNotNull(retrievedBean);
|
||||
assertEquals(beanInstance, retrievedBean);
|
||||
assertTrue(container.containsBean(beanName));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should return null for non-existent bean")
|
||||
void testGetNonExistentBean() {
|
||||
// When
|
||||
Object result = container.getBean("nonExistent");
|
||||
|
||||
// Then
|
||||
assertNull(result);
|
||||
assertFalse(container.containsBean("nonExistent"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should register and retrieve bean by type")
|
||||
void testRegisterAndRetrieveByType() {
|
||||
// Given
|
||||
String testInstance = "Test String";
|
||||
|
||||
// When
|
||||
container.registerType(String.class, testInstance);
|
||||
String retrievedBean = container.getBean(String.class);
|
||||
|
||||
// Then
|
||||
assertNotNull(retrievedBean);
|
||||
assertEquals(testInstance, retrievedBean);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should register bean with constructor")
|
||||
void testRegisterBeanWithConstructor() {
|
||||
// When
|
||||
container.registerBean(TestService.class);
|
||||
TestService service = container.getBean(TestService.class);
|
||||
|
||||
// Then
|
||||
assertNotNull(service);
|
||||
assertEquals("TestService", service.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle bean post processors")
|
||||
void testBeanPostProcessors() {
|
||||
// Given
|
||||
when(mockBeanPostProcessor.postProcessBeforeInitialization(any(), anyString()))
|
||||
.thenAnswer(invocation -> invocation.getArgument(0));
|
||||
when(mockBeanPostProcessor.postProcessAfterInitialization(any(), anyString()))
|
||||
.thenAnswer(invocation -> invocation.getArgument(0));
|
||||
|
||||
container.addBeanPostProcessor(mockBeanPostProcessor);
|
||||
|
||||
// When
|
||||
container.registerBean(TestService.class);
|
||||
TestService service = container.getBean(TestService.class);
|
||||
|
||||
// Then
|
||||
assertNotNull(service);
|
||||
verify(mockBeanPostProcessor).postProcessBeforeInitialization(any(TestService.class), eq("testService"));
|
||||
verify(mockBeanPostProcessor).postProcessAfterInitialization(any(TestService.class), eq("testService"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should check singleton scope correctly")
|
||||
void testSingletonScope() {
|
||||
// Given
|
||||
String beanName = "singletonBean";
|
||||
String instance = "singleton";
|
||||
|
||||
// When
|
||||
container.registerSingleton(beanName, instance);
|
||||
|
||||
// Then
|
||||
assertTrue(container.isSingleton(beanName));
|
||||
assertFalse(container.isPrototype(beanName));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get beans by type")
|
||||
void testGetBeansByType() {
|
||||
// Given
|
||||
String instance1 = "String1";
|
||||
String instance2 = "String2";
|
||||
|
||||
container.registerSingleton("string1", instance1);
|
||||
container.registerSingleton("string2", instance2);
|
||||
|
||||
// When
|
||||
java.util.Map<String, String> stringBeans = container.getBeansOfType(String.class);
|
||||
|
||||
// Then
|
||||
assertEquals(2, stringBeans.size());
|
||||
assertTrue(stringBeans.containsValue(instance1));
|
||||
assertTrue(stringBeans.containsValue(instance2));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get bean names for type")
|
||||
void testGetBeanNamesForType() {
|
||||
// Given
|
||||
String instance = "test";
|
||||
container.registerSingleton("stringBean", instance);
|
||||
|
||||
// When
|
||||
String[] beanNames = container.getBeanNamesForType(String.class);
|
||||
|
||||
// Then
|
||||
assertEquals(1, beanNames.length);
|
||||
assertEquals("stringBean", beanNames[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should manage container lifecycle")
|
||||
void testContainerLifecycle() {
|
||||
// Given
|
||||
assertFalse(container.isRunning());
|
||||
|
||||
// When
|
||||
container.start();
|
||||
|
||||
// Then
|
||||
assertTrue(container.isRunning());
|
||||
|
||||
// When
|
||||
container.stop();
|
||||
|
||||
// Then
|
||||
assertFalse(container.isRunning());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get bean factory")
|
||||
void testGetBeanFactory() {
|
||||
// When
|
||||
BeanFactory factory = container.getBeanFactory();
|
||||
|
||||
// Then
|
||||
assertNotNull(factory);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should get autowire capable bean factory")
|
||||
void testGetAutowireCapableBeanFactory() {
|
||||
// When
|
||||
AutowireFactory factory = container.getAutowireCapableBeanFactory();
|
||||
|
||||
// Then
|
||||
assertNotNull(factory);
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@ValueSource(strings = {"bean1", "bean2", "bean3"})
|
||||
@DisplayName("Should handle multiple bean registrations")
|
||||
void testMultipleBeanRegistrations(String beanName) {
|
||||
// Given
|
||||
String instance = "Instance for " + beanName;
|
||||
|
||||
// When
|
||||
container.registerSingleton(beanName, instance);
|
||||
|
||||
// Then
|
||||
assertTrue(container.containsBean(beanName));
|
||||
assertEquals(instance, container.getBean(beanName));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should close container properly")
|
||||
void testCloseContainer() {
|
||||
// Given
|
||||
container.registerSingleton("test", "instance");
|
||||
assertTrue(container.containsBean("test"));
|
||||
|
||||
// When
|
||||
container.close();
|
||||
|
||||
// Then
|
||||
assertFalse(container.containsBean("test"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Should handle parent-child container relationship")
|
||||
void testParentChildContainer() {
|
||||
// Given
|
||||
SimpleContainer parent = new SimpleContainer();
|
||||
parent.registerSingleton("parentBean", "parentValue");
|
||||
|
||||
SimpleContainer child = new SimpleContainer(parent);
|
||||
|
||||
// When
|
||||
Object parentBean = child.getBean("parentBean");
|
||||
|
||||
// Then
|
||||
assertNotNull(parentBean);
|
||||
assertEquals("parentValue", parentBean);
|
||||
}
|
||||
|
||||
// Test helper class
|
||||
public static class TestService {
|
||||
public String getName() {
|
||||
return "TestService";
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue