[Unit Test Generation] Test UT generate on Center

center/src/test/java/com/microsoft/hydralab/center/config/AADOauth2ConfigurationTest.java

@@ -0,0 +1,21 @@
+package com.microsoft.hydralab.center.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.mockito.Mockito;
+import org.junit.Test;
+
+public class AADOauth2ConfigurationTest {
+
+    @Test
+    public void testConfigure() {
+        AADOauth2Configuration configuration = new AADOauth2Configuration();
+        HttpSecurity http = Mockito.mock(HttpSecurity.class);
+
+        configuration.configure(http);
+    }
+}

center/src/test/java/com/microsoft/hydralab/center/config/AppConfigTest.java

@@ -0,0 +1,150 @@
+package com.microsoft.hydralab.center.config;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.alibaba.fastjson.support.config.FastJsonConfig;
+import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.http.MediaType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.context.ApplicationContext;
+import org.springframework.security.core.session.SessionRegistry;
+import org.springframework.security.core.session.SessionRegistryImpl;
+import org.springframework.security.web.session.HttpSessionEventPublisher;
+import org.mockito.Mockito;
+import org.springframework.boot.actuate.metrics.export.prometheus.PrometheusProperties;
+import java.net.MalformedURLException;
+import org.springframework.boot.actuate.autoconfigure.metrics.export.prometheus.PrometheusProperties;
+import org.springframework.boot.actuate.metrics.export.prometheus.PrometheusPushGatewayManager;
+import io.prometheus.client.CollectorRegistry;
+import io.prometheus.client.exporter.PushGateway;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+
+public class AppConfigTest {
+
+    @Mock
+    private FastJsonConfig fastJsonConfig;
+    @Mock
+    private ApplicationContext applicationContext;
+    @Mock
+    private SessionRegistry sessionRegistry;
+    @Mock
+    private HttpSessionEventPublisher httpSessionEventPublisher;
+    @Mock
+    private FileReporter fileReporter;
+    @Mock
+    private AppCenterReporter appCenterReporter;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testFastJsonHttpMessageConverter() {
+        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
+        List<MediaType> supportedMediaTypes = new ArrayList<>();
+        supportedMediaTypes.add(MediaType.APPLICATION_JSON);
+        supportedMediaTypes.add(MediaType.APPLICATION_ATOM_XML);
+        supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
+        supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
+        supportedMediaTypes.add(MediaType.APPLICATION_PDF);
+        supportedMediaTypes.add(MediaType.APPLICATION_RSS_XML);
+        supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
+        supportedMediaTypes.add(MediaType.APPLICATION_XML);
+        supportedMediaTypes.add(MediaType.IMAGE_GIF);
+        supportedMediaTypes.add(MediaType.IMAGE_JPEG);
+        supportedMediaTypes.add(MediaType.IMAGE_PNG);
+        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
+        supportedMediaTypes.add(MediaType.TEXT_HTML);
+        supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
+        supportedMediaTypes.add(MediaType.TEXT_PLAIN);
+        supportedMediaTypes.add(MediaType.TEXT_XML);
+        fastConverter.setSupportedMediaTypes(supportedMediaTypes);
+        when(fastJsonConfig.getSerializerFeatures()).thenReturn(
+                SerializerFeature.WriteMapNullValue,
+                SerializerFeature.WriteNullStringAsEmpty,
+                SerializerFeature.WriteNullListAsEmpty,
+                SerializerFeature.DisableCircularReferenceDetect
+        );
+        fastConverter.setFastJsonConfig(fastJsonConfig);
+        assertEquals(supportedMediaTypes, fastConverter.getSupportedMediaTypes());
+        assertEquals(fastJsonConfig, fastConverter.getFastJsonConfig());
+    }
+
+    @Test
+    public void testStorageServiceClientProxy() {
+        AppConfig appConfig = new AppConfig();
+        appConfig.storageServiceClientProxy(applicationContext);
+    }
+
+    @Test
+    public void testSessionRegistry() {
+        SessionRegistryImpl sessionRegistryImpl = new SessionRegistryImpl();
+    }
+
+    @Test
+    public void testEventPublisher() {
+        AppConfig appConfig = new AppConfig();
+        HttpSessionEventPublisher eventPublisher = appConfig.eventPublisher();
+    }
+
+    @Test
+    public void testPushGateway() {
+        PrometheusProperties prometheusProperties = Mockito.mock(PrometheusProperties.class);
+        AppConfig appConfig = new AppConfig();
+        appConfig.pushGateway(prometheusProperties);
+    }
+
+    @Test
+    public void testMonitorPrometheusPushGatewayManager() {
+        PushGateway pushGateway = Mockito.mock(PushGateway.class);
+        PrometheusProperties prometheusProperties = Mockito.mock(PrometheusProperties.class);
+        CollectorRegistry registry = Mockito.mock(CollectorRegistry.class);
+        PrometheusProperties.Pushgateway pushgatewayProperties = Mockito.mock(PrometheusProperties.Pushgateway.class);
+        Mockito.when(prometheusProperties.getPushgateway()).thenReturn(pushgatewayProperties);
+        Mockito.when(pushgatewayProperties.getBaseUrl()).thenReturn("http:");
+        Mockito.when(pushgatewayProperties.getPushRate()).thenReturn(Duration.ofSeconds(10));
+        Mockito.when(pushgatewayProperties.getJob()).thenReturn("testJob");
+        Map<String, String> groupingKey = new HashMap<>();
+        groupingKey.put("key1", "value1");
+        groupingKey.put("key2", "value2");
+        Mockito.when(pushgatewayProperties.getGroupingKey()).thenReturn(groupingKey);
+        PrometheusPushGatewayManager.ShutdownOperation shutdownOperation = Mockito.mock(PrometheusPushGatewayManager.ShutdownOperation.class);
+        Mockito.when(pushgatewayProperties.getShutdownOperation()).thenReturn(shutdownOperation);
+        AppConfig appConfig = new AppConfig();
+        appConfig.monitorPrometheusPushGatewayManager(pushGateway, prometheusProperties, registry);
+        Mockito.verify(pushGateway, Mockito.times(1)).setConnectionFactory(Mockito.any());
+        Mockito.verify(pushGateway, Mockito.times(1)).isBasicAuthSet();
+        Mockito.verify(registry, Mockito.times(1)).register(Mockito.any());
+    }
+
+    @Test
+    public void testFileReporter() {
+        AppConfig appConfig = new AppConfig();
+        appConfig.fileReporter();
+        verify(fileReporter, times(1)).init(anyString());
+        verify(fileReporter, times(1)).registerExceptionReporter();
+    }
+
+    @Test
+    public void testAppCenterReporter() {
+
+    }
+
+}

center/src/test/java/com/microsoft/hydralab/center/config/ContextStartupTest.java

@@ -0,0 +1,51 @@
+package com.microsoft.hydralab.center.config;
+
+import com.microsoft.hydralab.center.config.ContextStartup;
+import com.microsoft.hydralab.center.service.DeviceAgentManagementService;
+import com.microsoft.hydralab.center.util.MetricUtil;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.servlet.ServletContext;
+
+import static org.mockito.Mockito.*;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+@ActiveProfiles("test")
+public class ContextStartupTest {
+
+    @Mock
+    private MetricUtil metricUtil;
+
+    @Mock
+    private DeviceAgentManagementService deviceAgentManagementService;
+
+    @Mock
+    private ApplicationArguments applicationArguments;
+
+    @Mock
+    private ServletContext servletContext;
+
+    private ContextStartup contextStartup;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        contextStartup = new ContextStartup();
+        contextStartup.setServletContext(servletContext);
+    }
+
+    @Test
+    public void testRun() {
+        contextStartup.run(applicationArguments);
+        verify(deviceAgentManagementService, times(1)).registerOnlineAgent(deviceAgentManagementService);
+        verify(deviceAgentManagementService, times(1)).registerOnlineDevice(deviceAgentManagementService);
+    }
+}

center/src/test/java/com/microsoft/hydralab/center/config/SecurityConfigurationTest.java

@@ -0,0 +1,47 @@
+package com.microsoft.hydralab.center.config;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.provisioning.InMemoryUserDetailsManager;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.authentication.AuthenticationManager;
+
+@RunWith(MockitoJUnitRunner.class)
+public class SecurityConfigurationTest {
+
+    @Mock
+    private InMemoryUserDetailsManager userDetailsManager;
+
+    @Mock
+    private BCryptPasswordEncoder bCryptPasswordEncoder;
+
+    @Test
+    public void testUserDetailsService() {
+        Mockito.when(userDetailsManager.loadUserByUsername(Mockito.anyString())).thenReturn(null);
+        SecurityConfiguration securityConfiguration = new SecurityConfiguration();
+        UserDetailsService userDetailsService = securityConfiguration.userDetailsService();
+    }
+
+    @Test
+    public void testPasswordEncoder() {
+        PasswordEncoder passwordEncoder = Mockito.mock(BCryptPasswordEncoder.class);
+        SecurityConfiguration securityConfiguration = new SecurityConfiguration();
+        Mockito.when(passwordEncoder.encode(Mockito.anyString())).thenReturn("encodedPassword");
+        PasswordEncoder result = securityConfiguration.passwordEncoder();
+        Mockito.verify(passwordEncoder).encode(Mockito.anyString());
+        Mockito.verifyNoMoreInteractions(passwordEncoder);
+    }
+
+    @Test
+    public void testAuthenticationManagerBean() {
+        SecurityConfiguration securityConfiguration = new SecurityConfiguration();
+        Mockito.when(userDetailsManager.createUser(Mockito.any())).thenReturn(null);
+        Mockito.when(userDetailsManager.loadUserByUsername(Mockito.anyString())).thenReturn(null);
+        AuthenticationManager authenticationManager = securityConfiguration.authenticationManagerBean();
+    }
+}

center/src/test/java/com/microsoft/hydralab/center/config/WebMvcConfigurationTest.java

@@ -0,0 +1,51 @@
+package com.microsoft.hydralab.center.config;
+
+import com.microsoft.hydralab.center.config.WebMvcConfiguration;
+import com.microsoft.hydralab.center.interceptor.BaseInterceptor;
+import com.microsoft.hydralab.center.interceptor.CorsInterceptor;
+import com.microsoft.hydralab.common.util.Const;
+import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
+
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
+
+public class WebMvcConfigurationTest {
+
+    @Mock
+    private BaseInterceptor baseInterceptor;
+    @Mock
+    private CorsInterceptor corsInterceptor;
+    @Mock
+    private FastJsonHttpMessageConverter fastJsonHttpMessageConverter;
+    @Mock
+    private ViewControllerRegistry viewControllerRegistry;
+    @Mock
+    private InterceptorRegistry interceptorRegistry;
+    private WebMvcConfiguration webMvcConfiguration;
+    @Mock
+    private InterceptorRegistry registry;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        webMvcConfiguration = new WebMvcConfiguration();
+    }
+
+    @Test
+    public void testAddViewControllers() {
+        webMvcConfiguration.addViewControllers(viewControllerRegistry);
+        verify(viewControllerRegistry).addViewController("/portal/").setViewName("forward:" + Const.FrontEndPath.INDEX_PATH);
+    }
+
+    @Test
+    public void testAddInterceptors() {
+        webMvcConfiguration.addInterceptors(registry);
+        verify(registry).addInterceptor(baseInterceptor);
+    }
+}

center/src/test/java/com/microsoft/hydralab/center/config/WebSocketConfigTest.java

@@ -0,0 +1,40 @@
+package com.microsoft.hydralab.center.config;
+
+import com.microsoft.hydralab.center.config.WebSocketConfig;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import static org.junit.Assert.assertNotNull;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.web.socket.server.standard.ServletServerContainerFactoryBean;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.mock;
+
+@RunWith(MockitoJUnitRunner.class)
+public class WebSocketConfigTest {
+
+    private WebSocketConfig webSocketConfig;
+    @Mock
+    private ServletServerContainerFactoryBean container;
+
+    @Before
+    public void setUp() {
+        webSocketConfig = new WebSocketConfig();
+    }
+
+    @Test
+    public void testServerEndpointExporter() {
+        ServerEndpointExporter serverEndpointExporter = webSocketConfig.serverEndpointExporter();
+        assertNotNull(serverEndpointExporter);
+    }
+
+    @Test
+    public void testCreateWebSocketContainer() {
+        when(container.getMaxTextMessageBufferSize()).thenReturn(100000);
+        when(container.getMaxBinaryMessageBufferSize()).thenReturn(100000);
+        ServletServerContainerFactoryBean result = webSocketConfig.createWebSocketContainer();
+        assertSame(container, result);
+    }
+}