| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.felix.http.base.internal.runtime.dto; |
| |
| |
| //@RunWith(MockitoJUnitRunner.class) |
| public class RuntimeDTOBuilderTest |
| { |
| /* |
| @Rule |
| public ExpectedException expectedException = ExpectedException.none(); |
| |
| private static final Long ID_0 = -ID_COUNTER.incrementAndGet(); |
| private static final Long ID_A = ID_COUNTER.incrementAndGet(); |
| private static final Long ID_B = ID_COUNTER.incrementAndGet(); |
| private static final Long ID_C = ID_COUNTER.incrementAndGet(); |
| private static final Long ID_D = ID_COUNTER.incrementAndGet(); |
| |
| private static final Long ID_LISTENER_1 = ID_COUNTER.incrementAndGet(); |
| private static final Long ID_LISTENER_2 = ID_COUNTER.incrementAndGet(); |
| |
| private static final List<String> CONTEXT_NAMES = Arrays.asList("0", "A", "B"); |
| |
| @SuppressWarnings("serial") |
| private static final Map<String, List<String>> CONTEXT_ENTITY_NAMES = new HashMap<String, List<String>>() |
| { |
| { |
| put("0", Arrays.asList("1")); |
| put("A", Arrays.asList("A_1")); |
| put("B", Arrays.asList("B_1", "B_2")); |
| } |
| }; |
| |
| @SuppressWarnings("serial") |
| private static final Map<String, Object> RUNTIME_ATTRIBUTES = new HashMap<String, Object>() |
| { |
| { |
| put("attr_1", "val_1"); |
| put("attr_2", "val_2"); |
| } |
| }; |
| |
| @Mock private Bundle bundle; |
| |
| @Mock private DTO testDTO; |
| |
| @Mock private ExtServletContext context_0; |
| @Mock private ExtServletContext context_A; |
| @Mock private ExtServletContext context_B; |
| @Mock private ExtServletContext context_C; |
| @Mock private ExtServletContext context_D; |
| |
| @Mock private ServiceReference<?> listener_1; |
| @Mock private ServiceReference<?> listener_2; |
| |
| @Mock private ServiceReference<Object> resource; |
| |
| @Mock private ServiceReference<HttpServiceRuntime> runtimeReference; |
| |
| private RegistryRuntime registry; |
| private Map<String, Object> runtimeAttributes; |
| |
| @Before |
| public void setUp() |
| { |
| registry = null; |
| runtimeAttributes = RUNTIME_ATTRIBUTES; |
| when(bundle.getBundleId()).thenReturn(47L); |
| when(runtimeReference.getBundle()).thenReturn(bundle); |
| when(runtimeReference.getUsingBundles()).thenReturn(null); |
| when(runtimeReference.getPropertyKeys()).thenReturn(runtimeAttributes.keySet().toArray(new String[5])); |
| for(final String key : runtimeAttributes.keySet()) |
| { |
| when(runtimeReference.getProperty(key)).thenReturn(runtimeAttributes.get(key)); |
| } |
| when(runtimeReference.getProperty(Constants.SERVICE_ID)).thenReturn(39L); |
| } |
| |
| public ServletContextHelperRuntime setupContext(ServletContext context, String name, long serviceId) |
| { |
| when(context.getServletContextName()).thenReturn(name); |
| |
| String path = "/" + name; |
| when(context.getContextPath()).thenReturn(path); |
| |
| List<String> initParameterNames = asList("param_1", "param_2"); |
| when(context.getInitParameterNames()).thenReturn(Collections.enumeration(initParameterNames)); |
| when(context.getInitParameter("param_1")).thenReturn("init_val_1"); |
| when(context.getInitParameter("param_2")).thenReturn("init_val_2"); |
| |
| Map<String, String> initParameters = createInitParameterMap(); |
| ServletContextHelperInfo contextInfo = createContextInfo(0, serviceId, name, path, initParameters); |
| |
| ContextHandler contextHandler = new ContextHandler(contextInfo, context, bundle); |
| PerContextEventListener eventListener = contextHandler.getListenerRegistry(); |
| |
| ServletContext sharedContext = contextHandler.getSharedContext(); |
| sharedContext.setAttribute("intAttr", 1); |
| sharedContext.setAttribute("dateAttr", new Date()); |
| sharedContext.setAttribute("stringAttr", "one"); |
| sharedContext.setAttribute("dtoAttr", testDTO); |
| |
| // TODO |
| return null; |
| // return contextHandler; |
| } |
| |
| private Map<String, String> createInitParameterMap() |
| { |
| Map<String, String> initParameters = new HashMap<String, String>(); |
| initParameters.put("param_1", "init_val_1"); |
| initParameters.put("param_2", "init_val_2"); |
| return initParameters; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public Map<Long, Collection<ServiceReference<?>>> setupListeners() |
| { |
| Map<Long, Collection<ServiceReference<?>>> listenerRuntimes = new HashMap<Long, Collection<ServiceReference<?>>>(); |
| |
| listenerRuntimes.put(ID_0, asList(listener_1, listener_2)); |
| listenerRuntimes.put(ID_A, Arrays.<ServiceReference<?>>asList(listener_1)); |
| listenerRuntimes.put(ID_B, asList(listener_1, listener_2)); |
| |
| when(listener_1.getProperty(Constants.SERVICE_ID)).thenReturn(ID_LISTENER_1); |
| when(listener_1.getProperty(Constants.OBJECTCLASS)) |
| .thenReturn(new String[] { "org.test.interface_1" }); |
| |
| when(listener_2.getProperty(Constants.SERVICE_ID)).thenReturn(ID_LISTENER_2); |
| when(listener_2.getProperty(Constants.OBJECTCLASS)) |
| .thenReturn(new String[] { "org.test.interface_1", "org.test.interface_2" }); |
| |
| return listenerRuntimes; |
| } |
| |
| public void setupResource() |
| { |
| when(resource.getProperty(HttpWhiteboardConstants.HTTP_WHITEBOARD_RESOURCE_PATTERN)).thenReturn(new String[] { "/" }); |
| when(resource.getProperty(HttpWhiteboardConstants.HTTP_WHITEBOARD_RESOURCE_PREFIX)).thenReturn("prefix"); |
| } |
| |
| @Test |
| public void buildRuntimeDTO() |
| { |
| ServletContextHelperRuntime contextHelper_0 = setupContext(context_0, "0", ID_0); |
| ServletContextHelperRuntime contextHelper_A = setupContext(context_A, "A", ID_A); |
| ServletContextHelperRuntime contextHelper_B = setupContext(context_B, "B", ID_B); |
| |
| List<ServletHandler> servlets = new ArrayList<ServletHandler>(); |
| List<ServletHandler> resources = new ArrayList<ServletHandler>(); |
| |
| servlets.add(createTestServlet("1", context_0, ID_0)); |
| resources.add(createTestServlet("1", context_0, ID_0)); |
| List<FilterHandler> filters_0 = asList(createTestFilter("1", context_0)); |
| List<ServletState> errorPages_0 = asList(createErrorPage("E_1", context_0, ID_0)); |
| ContextRuntime contextRuntime_0 = new ContextRuntime(null, errorPages_0, null, null); |
| |
| servlets.add(createTestServlet("A_1", context_A, ID_A)); |
| resources.add(createTestServlet("A_1", context_A, ID_A)); |
| List<FilterHandler> filters_A = asList(createTestFilter("A_1", context_A)); |
| List<ServletState> errorPages_A = asList(createErrorPage("E_A_1", context_A, ID_A)); |
| ContextRuntime contextRuntime_A = new ContextRuntime(null, errorPages_A, null, null); |
| |
| servlets.addAll(asList(createTestServletWithServiceId("B_1", context_B, ID_B), |
| createTestServletWithServiceId("B_2", context_B, ID_B))); |
| resources.addAll(asList(createTestServletWithServiceId("B_1", context_B, ID_B), |
| createTestServletWithServiceId("B_2", context_B, ID_B))); |
| List<FilterHandler> filters_B = asList(createTestFilterWithServiceId("B_1", context_B), |
| createTestFilterWithServiceId("B_2", context_B)); |
| List<ServletState> errorPages_B = asList(createErrorPageWithServiceId("E_B_1", context_B, ID_B), |
| createErrorPageWithServiceId("E_B_2", context_B, ID_B)); |
| ContextRuntime contextRuntime_B = new ContextRuntime(null, errorPages_B, null, null); |
| |
| Map<Long, Collection<ServiceReference<?>>> listenerRuntimes = setupListeners(); |
| |
| setupRegistry(asList(contextHelper_0, contextHelper_A, contextHelper_B), |
| asList(contextRuntime_0, contextRuntime_A, contextRuntime_B), |
| // new ServletRegistryRuntime(servlets, resources), |
| listenerRuntimes, |
| null); |
| |
| RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build(); |
| |
| assertEquals(0, runtimeDTO.failedErrorPageDTOs.length); |
| assertEquals(0, runtimeDTO.failedFilterDTOs.length); |
| assertEquals(0, runtimeDTO.failedListenerDTOs.length); |
| assertEquals(0, runtimeDTO.failedResourceDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletDTOs.length); |
| |
| assertServletContextDTOs(runtimeDTO); |
| } |
| |
| private void assertServletContextDTOs(RuntimeDTO runtimeDTO) |
| { |
| SortedSet<Long> seenServiceIds = new TreeSet<Long>(); |
| |
| assertEquals(3, runtimeDTO.servletContextDTOs.length); |
| |
| for (ServletContextDTO servletContextDTO : runtimeDTO.servletContextDTOs) |
| { |
| String contextName = servletContextDTO.name; |
| assertTrue(CONTEXT_NAMES.contains(contextName)); |
| if (contextName.equals("0")) |
| { |
| assertTrue(contextName, |
| servletContextDTO.serviceId < 0); |
| assertEquals(contextName, |
| 1, servletContextDTO.servletDTOs.length); |
| assertEquals(contextName, |
| 1, servletContextDTO.filterDTOs.length); |
| assertEquals(contextName, |
| 1, servletContextDTO.resourceDTOs.length); |
| assertEquals(contextName, |
| 1, servletContextDTO.errorPageDTOs.length); |
| assertEquals(contextName, |
| 2, servletContextDTO.listenerDTOs.length); |
| } |
| else |
| { |
| int expectedId = CONTEXT_NAMES.indexOf(contextName) + 1; |
| assertEquals(contextName, |
| expectedId, servletContextDTO.serviceId); |
| |
| int expectedChildren = CONTEXT_NAMES.indexOf(contextName); |
| assertEquals(contextName, |
| expectedChildren, servletContextDTO.servletDTOs.length); |
| assertEquals(contextName, |
| expectedChildren, servletContextDTO.filterDTOs.length); |
| assertEquals(contextName, |
| expectedChildren, servletContextDTO.resourceDTOs.length); |
| assertEquals(contextName, |
| expectedChildren, servletContextDTO.errorPageDTOs.length); |
| assertEquals(contextName, |
| expectedChildren, servletContextDTO.listenerDTOs.length); |
| } |
| seenServiceIds.add(servletContextDTO.serviceId); |
| |
| assertEquals(contextName, |
| 3, servletContextDTO.attributes.size()); |
| assertEquals(contextName, |
| 1, servletContextDTO.attributes.get("intAttr")); |
| assertEquals(contextName, |
| "one", servletContextDTO.attributes.get("stringAttr")); |
| assertEquals(contextName, |
| testDTO, servletContextDTO.attributes.get("dtoAttr")); |
| |
| assertEquals(contextName, |
| 2, servletContextDTO.initParams.size()); |
| assertEquals(contextName, |
| "init_val_1", servletContextDTO.initParams.get("param_1")); |
| assertEquals(contextName, |
| "init_val_2", servletContextDTO.initParams.get("param_2")); |
| |
| assertEquals(contextName, |
| "/" + contextName + "/" + contextName, servletContextDTO.contextPath); |
| |
| Collection<Long> serviceIds = assertServletDTOs(contextName, |
| servletContextDTO.serviceId, servletContextDTO.servletDTOs); |
| seenServiceIds.addAll(serviceIds); |
| |
| serviceIds = assertFilterDTOs(contextName, |
| servletContextDTO.serviceId, servletContextDTO.filterDTOs); |
| seenServiceIds.addAll(serviceIds); |
| |
| serviceIds = assertResourceDTOs(contextName, |
| servletContextDTO.serviceId, servletContextDTO.resourceDTOs); |
| seenServiceIds.addAll(serviceIds); |
| |
| serviceIds = assertErrorPageDTOs(contextName, |
| servletContextDTO.serviceId, servletContextDTO.errorPageDTOs); |
| seenServiceIds.addAll(serviceIds); |
| |
| serviceIds = assertListenerDTOs(contextName, |
| servletContextDTO.serviceId, servletContextDTO.listenerDTOs); |
| seenServiceIds.addAll(serviceIds); |
| } |
| assertEquals(12, seenServiceIds.tailSet(0L).size()); |
| assertEquals(9, seenServiceIds.headSet(0L).size()); |
| } |
| |
| private Collection<Long> assertServletDTOs(String contextName, long contextId, ServletDTO[] dtos) { |
| List<Long> serviceIds = new ArrayList<Long>(); |
| for (ServletDTO servletDTO : dtos) |
| { |
| String name = servletDTO.name; |
| assertTrue(CONTEXT_ENTITY_NAMES.get(contextName).contains(name)); |
| |
| if (contextId != ID_B) |
| { |
| assertTrue(name, |
| servletDTO.serviceId < 0); |
| } |
| else |
| { |
| assertTrue(name, |
| servletDTO.serviceId > 0); |
| } |
| serviceIds.add(servletDTO.serviceId); |
| |
| assertEquals(name, |
| contextId, servletDTO.servletContextId); |
| |
| assertTrue(name, |
| servletDTO.asyncSupported); |
| |
| assertEquals(name, |
| 2, servletDTO.initParams.size()); |
| assertEquals(name, |
| "valOne_" + name, servletDTO.initParams.get("paramOne_" + name)); |
| assertEquals(name, |
| "valTwo_" + name, servletDTO.initParams.get("paramTwo_" + name)); |
| |
| assertEquals(name, |
| 1, servletDTO.patterns.length); |
| assertEquals(name, |
| "/" + name, servletDTO.patterns[0]); |
| |
| assertEquals(name, |
| "info_" + name, servletDTO.servletInfo); |
| } |
| |
| return serviceIds; |
| } |
| |
| private Collection<Long> assertFilterDTOs(String contextName, long contextId, FilterDTO[] dtos) { |
| List<Long> serviceIds = new ArrayList<Long>(); |
| for (FilterDTO filterDTO : dtos) |
| { |
| String name = filterDTO.name; |
| assertTrue(CONTEXT_ENTITY_NAMES.get(contextName).contains(name)); |
| |
| if (contextId != ID_B) |
| { |
| assertTrue(name, |
| filterDTO.serviceId < 0); |
| } |
| else |
| { |
| assertTrue(name, |
| filterDTO.serviceId > 0); |
| } |
| serviceIds.add(filterDTO.serviceId); |
| |
| assertEquals(name, |
| contextId, filterDTO.servletContextId); |
| |
| assertTrue(name, |
| filterDTO.asyncSupported); |
| |
| assertEquals(name, |
| 2, filterDTO.initParams.size()); |
| assertEquals(name, |
| "valOne_" + name, filterDTO.initParams.get("paramOne_" + name)); |
| assertEquals(name, |
| "valTwo_" + name, filterDTO.initParams.get("paramTwo_" + name)); |
| |
| assertEquals(name, |
| 1, filterDTO.patterns.length); |
| assertEquals(name, |
| "/" + name, filterDTO.patterns[0]); |
| |
| assertEquals(name, |
| 1, filterDTO.regexs.length); |
| assertEquals(name, |
| "." + name, filterDTO.regexs[0]); |
| |
| assertEquals(name, |
| 2, filterDTO.dispatcher.length); |
| assertEquals(name, |
| "ASYNC", filterDTO.dispatcher[0]); |
| assertEquals(name, |
| "REQUEST", filterDTO.dispatcher[1]); |
| } |
| |
| return serviceIds; |
| } |
| |
| private Collection<Long> assertResourceDTOs(String contextName, long contextId, ResourceDTO[] dtos) { |
| List<Long> serviceIds = new ArrayList<Long>(); |
| for (ResourceDTO resourceDTO : dtos) |
| { |
| if (contextId != ID_B) |
| { |
| assertTrue(contextId + " " + contextName, |
| resourceDTO.serviceId < 0); |
| } |
| else |
| { |
| assertTrue(contextId + " " + contextName, |
| resourceDTO.serviceId > 0); |
| } |
| serviceIds.add(resourceDTO.serviceId); |
| |
| assertEquals(contextId + " " + contextName, |
| contextId, resourceDTO.servletContextId); |
| |
| assertEquals(contextId + " " + contextName, |
| 1, resourceDTO.patterns.length); |
| assertTrue(contextId + " " + contextName, |
| resourceDTO.patterns[0].startsWith("/")); |
| } |
| return serviceIds; |
| } |
| |
| private Collection<Long> assertErrorPageDTOs(String contextName, long contextId, ErrorPageDTO[] dtos) |
| { |
| List<Long> serviceIds = new ArrayList<Long>(); |
| for (ErrorPageDTO errorPageDTO : dtos) |
| { |
| String name = errorPageDTO.name; |
| assertTrue(CONTEXT_ENTITY_NAMES.get(contextName).contains(name.substring(2))); |
| |
| if (contextId != ID_B) |
| { |
| assertTrue(name, |
| errorPageDTO.serviceId < 0); |
| } |
| else |
| { |
| assertTrue(name, |
| errorPageDTO.serviceId > 0); |
| } |
| serviceIds.add(errorPageDTO.serviceId); |
| |
| assertEquals(name, |
| contextId, errorPageDTO.servletContextId); |
| |
| assertTrue(name, |
| errorPageDTO.asyncSupported); |
| |
| assertEquals(name, |
| 2, errorPageDTO.initParams.size()); |
| assertEquals(name, |
| "valOne_" + name, errorPageDTO.initParams.get("paramOne_" + name)); |
| assertEquals(name, |
| "valTwo_" + name, errorPageDTO.initParams.get("paramTwo_" + name)); |
| |
| assertEquals(name, |
| "info_" + name, errorPageDTO.servletInfo); |
| |
| assertEquals(name, |
| 2, errorPageDTO.errorCodes.length); |
| long[] errorCodes = copyOf(errorPageDTO.errorCodes, 2); |
| sort(errorCodes); |
| assertEquals(name, |
| 400, errorCodes[0]); |
| assertEquals(name, |
| 500, errorCodes[1]); |
| |
| assertEquals(name, |
| 2, errorPageDTO.exceptions.length); |
| String[] exceptions = copyOf(errorPageDTO.exceptions, 2); |
| sort(exceptions); |
| assertEquals(name, |
| "Bad request", exceptions[0]); |
| assertEquals(name, |
| "Error", exceptions[1]); |
| } |
| |
| return serviceIds; |
| } |
| |
| private Collection<Long> assertListenerDTOs(String contextName, long contextId, ListenerDTO[] dtos) |
| { |
| Set<Long> serviceIds = new HashSet<Long>(); |
| for (ListenerDTO listenerDTO : dtos) |
| { |
| assertEquals(contextId, listenerDTO.servletContextId); |
| serviceIds.add(listenerDTO.serviceId); |
| } |
| |
| assertEquals(ID_LISTENER_1.longValue(), dtos[0].serviceId); |
| assertArrayEquals(new String[] { "org.test.interface_1" }, |
| dtos[0].types); |
| if (dtos.length > 1) |
| { |
| assertEquals(ID_LISTENER_2.longValue(), dtos[1].serviceId); |
| assertArrayEquals(new String[] { "org.test.interface_1", "org.test.interface_2" }, dtos[1].types); |
| } |
| |
| return serviceIds; |
| } |
| |
| @Test |
| public void nullValuesInEntities() { |
| ServletContextHelperRuntime contextHandler = setupContext(context_0, "0", ID_0); |
| |
| ServletInfo servletInfo = createServletInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "1", |
| new String[] { "/*" }, |
| null, |
| true, |
| Collections.<String, String>emptyMap()); |
| Servlet servlet = mock(Servlet.class); |
| ServletHandler servletHandler = new HttpServiceServletHandler(0, context_0, servletInfo, servlet); |
| when(servlet.getServletInfo()).thenReturn("info_0"); |
| |
| FilterInfo filterInfo = createFilterInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "1", |
| null, |
| null, |
| null, |
| true, |
| null, |
| Collections.<String, String>emptyMap()); |
| FilterHandler filterHandler = new HttpServiceFilterHandler(0, context_0, filterInfo, mock(Filter.class)); |
| |
| ServletInfo resourceInfo = createServletInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "1", |
| new String[] { "/*" }, |
| null, |
| true, |
| Collections.<String, String>emptyMap()); |
| Servlet resource = mock(Servlet.class); |
| ServletHandler resourceHandler = new HttpServiceServletHandler(ID_0, context_0, resourceInfo, resource); |
| |
| ContextRuntime contextRuntime = new ContextRuntime(null, |
| Collections.<ServletState>emptyList(), |
| null, null); |
| setupRegistry(asList(contextHandler), asList(contextRuntime), |
| // new ServletRegistryRuntime(asList(resourceHandler), asList(servletHandler)), |
| Collections.<Long, Collection<ServiceReference<?>>>emptyMap(), |
| null); |
| |
| RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build(); |
| |
| assertEquals(1, runtimeDTO.servletContextDTOs.length); |
| assertEquals(1, runtimeDTO.servletContextDTOs[0].servletDTOs.length); |
| assertEquals(1, runtimeDTO.servletContextDTOs[0].filterDTOs.length); |
| |
| assertEquals(emptyMap(), runtimeDTO.servletContextDTOs[0].servletDTOs[0].initParams); |
| |
| assertEquals(emptyMap(), runtimeDTO.servletContextDTOs[0].filterDTOs[0].initParams); |
| assertEquals(0, runtimeDTO.servletContextDTOs[0].filterDTOs[0].patterns.length); |
| assertEquals(0, runtimeDTO.servletContextDTOs[0].filterDTOs[0].regexs.length); |
| } |
| |
| @Test |
| public void contextWithNoEntities() { |
| ServletContextHelperRuntime contextHandler_0 = setupContext(context_0, "0", ID_0); |
| ServletContextHelperRuntime contextHandler_A = setupContext(context_A, "A", ID_A); |
| |
| // TODO |
| setupRegistry(asList(contextHandler_0, contextHandler_A), |
| null, // asList(ContextRuntime.empty(ID_0), ContextRuntime.empty(ID_A)), |
| Collections.<Long, Collection<ServiceReference<?>>>emptyMap(), |
| null); |
| |
| RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build(); |
| |
| assertEquals(2, runtimeDTO.servletContextDTOs.length); |
| assertEquals(0, runtimeDTO.servletContextDTOs[0].servletDTOs.length); |
| assertEquals(0, runtimeDTO.servletContextDTOs[0].filterDTOs.length); |
| assertEquals(0, runtimeDTO.servletContextDTOs[1].servletDTOs.length); |
| assertEquals(0, runtimeDTO.servletContextDTOs[1].filterDTOs.length); |
| } |
| |
| @Test |
| public void missingPatternInServletThrowsException() |
| { |
| expectedException.expect(IllegalArgumentException.class); |
| expectedException.expectMessage("patterns"); |
| |
| ServletContextHelperRuntime contextHandler = setupContext(context_0, "0", ID_0); |
| |
| ServletInfo servletInfo = createServletInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "1", |
| null, |
| null, |
| true, |
| Collections.<String, String>emptyMap()); |
| Servlet servlet = mock(Servlet.class); |
| ServletHandler servletHandler = new HttpServiceServletHandler(ID_0, context_0, servletInfo, servlet); |
| when(servlet.getServletInfo()).thenReturn("info_0"); |
| |
| ContextRuntime contextRuntime = new ContextRuntime(Collections.<FilterState>emptyList(), |
| Collections.<ServletState>emptyList(), |
| null, null); |
| setupRegistry(asList(contextHandler), asList(contextRuntime), |
| // new ServletRegistryRuntime(asList(servletHandler), Collections.<ServletRuntime>emptyList()), |
| Collections.<Long, Collection<ServiceReference<?>>>emptyMap(), |
| null); |
| |
| new RuntimeDTOBuilder(registry, runtimeReference).build(); |
| } |
| |
| public FailureRuntime setupFailures() |
| { |
| Map<AbstractInfo<?>, Integer> serviceFailures = new HashMap<AbstractInfo<?>, Integer>(); |
| |
| ServletContextHelperInfo contextInfo = createContextInfo(0, |
| ID_C, |
| "context_failure_1", |
| "/", |
| createInitParameterMap()); |
| serviceFailures.put(contextInfo, 1); |
| |
| contextInfo = createContextInfo(0, |
| ID_D, |
| "context_failure_2", |
| "/", |
| createInitParameterMap()); |
| serviceFailures.put(contextInfo, 2); |
| |
| ServletInfo servletInfo = createServletInfo(0, ID_COUNTER.incrementAndGet(), |
| "servlet_failure_1", |
| new String[] {"/"}, |
| null, |
| false, |
| createInitParameterMap()); |
| serviceFailures.put(servletInfo, 3); |
| |
| servletInfo = createServletInfo(0, ID_COUNTER.incrementAndGet(), |
| "servlet_failure_2", |
| new String[] {"/"}, |
| null, |
| false, |
| createInitParameterMap()); |
| serviceFailures.put(servletInfo, 4); |
| |
| FilterInfo filterInfo = createFilterInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "filter_failure_1", |
| new String[] {"/"}, |
| null, |
| null, |
| false, |
| null, |
| createInitParameterMap()); |
| serviceFailures.put(filterInfo, 5); |
| |
| ServletInfo errorPageInfo = createServletInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "error_failure_1", |
| null, |
| new String[] { "405", "TestException" }, |
| false, |
| createInitParameterMap()); |
| serviceFailures.put(errorPageInfo, 6); |
| |
| ServletInfo invalidErrorPageInfo = createServletInfo(0, |
| ID_COUNTER.incrementAndGet(), |
| "error_failure_2", |
| new String[] { "/" }, |
| new String[] { "405", "TestException" }, |
| false, |
| createInitParameterMap()); |
| serviceFailures.put(invalidErrorPageInfo, 7); |
| |
| return FailureRuntime.builder().add(serviceFailures).build(); |
| } |
| |
| @Test |
| public void testFailureDTOs() |
| { |
| setupRegistry(Collections.<ServletContextHelperRuntime>emptyList(), |
| Collections.<ContextRuntime>emptyList(), |
| Collections.<Long, Collection<ServiceReference<?>>>emptyMap(), |
| setupFailures()); |
| |
| RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build(); |
| |
| assertEquals(0, runtimeDTO.servletContextDTOs.length); |
| |
| assertEquals(2, runtimeDTO.failedErrorPageDTOs.length); |
| assertEquals(1, runtimeDTO.failedFilterDTOs.length); |
| // ListenerInfo is hard to setup |
| assertEquals(0, runtimeDTO.failedListenerDTOs.length); |
| // ResourceInfo is hard to setup |
| assertEquals(0, runtimeDTO.failedResourceDTOs.length); |
| assertEquals(2, runtimeDTO.failedServletContextDTOs.length); |
| assertEquals(2, runtimeDTO.failedServletDTOs.length); |
| |
| assertEquals(1, runtimeDTO.failedServletContextDTOs[0].failureReason); |
| assertEquals(2, runtimeDTO.failedServletContextDTOs[1].failureReason); |
| assertEquals(3, runtimeDTO.failedServletDTOs[0].failureReason); |
| assertEquals(4, runtimeDTO.failedServletDTOs[1].failureReason); |
| assertEquals(5, runtimeDTO.failedFilterDTOs[0].failureReason); |
| assertEquals(6, runtimeDTO.failedErrorPageDTOs[0].failureReason); |
| assertEquals(7, runtimeDTO.failedErrorPageDTOs[1].failureReason); |
| |
| assertEquals("context_failure_1", runtimeDTO.failedServletContextDTOs[0].name); |
| assertEquals("context_failure_2", runtimeDTO.failedServletContextDTOs[1].name); |
| assertEquals("servlet_failure_1", runtimeDTO.failedServletDTOs[0].name); |
| assertEquals("servlet_failure_2", runtimeDTO.failedServletDTOs[1].name); |
| assertEquals("filter_failure_1", runtimeDTO.failedFilterDTOs[0].name); |
| assertEquals("error_failure_1", runtimeDTO.failedErrorPageDTOs[0].name); |
| assertEquals("error_failure_2", runtimeDTO.failedErrorPageDTOs[1].name); |
| |
| assertEquals(ID_C.longValue(), runtimeDTO.failedServletContextDTOs[0].serviceId); |
| assertEquals(ID_D.longValue(), runtimeDTO.failedServletContextDTOs[1].serviceId); |
| assertEquals(0, runtimeDTO.failedServletDTOs[0].servletContextId); |
| assertEquals(0, runtimeDTO.failedServletDTOs[1].servletContextId); |
| assertEquals(0, runtimeDTO.failedFilterDTOs[0].servletContextId); |
| assertEquals(0, runtimeDTO.failedErrorPageDTOs[0].servletContextId); |
| assertEquals(0, runtimeDTO.failedErrorPageDTOs[1].servletContextId); |
| |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[0].errorPageDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[0].filterDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[0].listenerDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[0].resourceDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[0].servletDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[1].errorPageDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[1].filterDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[1].listenerDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[1].resourceDTOs.length); |
| assertEquals(0, runtimeDTO.failedServletContextDTOs[1].servletDTOs.length); |
| |
| assertTrue(runtimeDTO.failedServletContextDTOs[0].attributes.isEmpty()); |
| assertTrue(runtimeDTO.failedServletContextDTOs[1].attributes.isEmpty()); |
| } |
| */ |
| } |
