def __init__(self,
servletContext=None,
method: str = None,
requestURI: str = None):
if servletContext is None:
self.servletContext = MockServletContext()
else:
self.servletContext = servletContext
self.method = method
self.requestURI = requestURI
self.locales.append(Locale.ENGLISH)
def setUp(self):
self.CONF: str = "/org/springframework/web/servlet/handler/map1.xml"
self.sc = MockServletContext("")
self.wac = StaticWebApplicationContext() # XmlWebApplicationContext
self.wac.set_servlet_context(self.sc)
# self.wac.set_config_location(sc)
self.wac.refresh()
def test_forward(self):
request = HttpServletRequest("GET", "/myservlet/handler.do")
request.set_context_path("/mycontext")
request.set_servlet_path("/myservlet")
request.set_path_info(";mypathinfo")
request.set_query_string("?param1=value1")
self.view.set_url(self.url)
tmp = MockServletContext()
tmp.minorVersion = 4
self.view.set_servlet_context(tmp)
self.view.render(self.model, request, self.response)
self.assertEqual(self.response.get_forwarded_url(), self.url)
for key, value in self.model.items():
msg = f"Values for model key '{key}' must match"
self.assertEqual(request.get_attribute(key), value, msg=msg)
def test_dynamic_model_overrides_static_attributes_if_collision(self):
wac = mock.MagicMock(spec=WebApplicationContext)
wac.get_servlet_context.return_value = MockServletContext()
request = MockHttpServletRequest()
response = MockHttpServletResponse()
view = testView(wac)
view.set_application_context(wac)
properties = {"one": "bar", "something": "else"}
view.set_attributes(properties)
model = {"one": {}, "two": object()}
view.render(model, request, response)
self.assertEqual(len(view.model), 3)
self.assertEqual(view.model.get("something"), "else")
self.assertTrue(view.initialized)
def test_render_with_static_attributes_no_collision(self):
wac = mock.MagicMock(spec=WebApplicationContext)
wac.get_servlet_context.return_value = MockServletContext()
request = MockHttpServletRequest()
response = MockHttpServletResponse()
view = testView(wac)
view.set_application_context(wac)
properties = {"foo": "bar", "something": "else"}
view.set_attributes(properties)
model = {"one": {}, "two": object()}
view.render(model, request, response)
self.assertEqual(dict(view.model, **model), view.model)
self.assertEqual(dict(view.model, **properties), view.model)
self.assertTrue(view.initialized)
def test_render_without_static_attributes(self):
wac = mock.MagicMock(spec=WebApplicationContext)
wac.get_servlet_context.return_value = MockServletContext()
# self.assertEqual(wac.get_servlet_context(), MockServletContext())
request = MockHttpServletRequest()
response = MockHttpServletResponse()
view = testView(wac)
# Check superclass handles duplicate init
view.set_application_context(wac)
view.set_application_context(wac)
model = {"foo": "bar", "something": object()}
view.render(model, request, response)
self.assertEqual(dict(view.model, **model), view.model)
self.assertTrue(view.initialized)
def test_dynamic_model_overrides_path_variables(self):
wac = mock.MagicMock(spec=WebApplicationContext)
wac.get_servlet_context.return_value = MockServletContext()
request = MockHttpServletRequest()
response = MockHttpServletResponse()
view = testView(wac)
view.set_application_context(wac)
pathVars = {"one": "bar", "something": "else"}
request.set_attribute(View.PATH_VARIABLES, pathVars)
model = {"one": {}, "two": object()}
view.render(model, request, response)
self.assertEqual(dict(view.model, **model), view.model)
self.assertEqual(len(view.model), 3)
self.assertEqual(view.model.get("something"), "else")
self.assertTrue(view.initialized)
class MockHttpServletRequest:
HTTP = "http"
HTTPS = "https"
CHARSET_PREFIX = "charset"
GMT = pytz.timezone("GMT")
EMPTY_SERVLET_INPUT_STREAM = DelegatingServletInputStream()
EMPTY_BUFFERED_READER = BufferedReader()
DATE_FORMATS = [
"%a %b %d %H:%M:%S %Y",
"%a, %d-%b-%y %H:%M:%S %Z",
"%a, %d %b %Y %H:%M:%S %Z",
]
# Public constants
DEFAULT_PROTOCOL = "HTTP/1.1"
DEFAULT_SCHEME: str = HTTP
DEFAULT_SERVER_ADDR = "127.0.0.1"
DEFAULT_SERVER_NAME = "localhost"
DEFAULT_SERVER_PORT = 80
DEFAULT_REMOTE_ADDR = "127.0.0.1"
DEFAULT_REMOTE_HOST = "localhost"
# Lifecycle properties
servletContext = None # mock
active = True
# ServletRequest properties
attributes = dict()
characterEncoding: str = None
content: bytes = None
contentType: str = None
inputStream = None # mock
reader = None # mock
parameters = dict()
protocol: str = DEFAULT_PROTOCOL
scheme: str = DEFAULT_SCHEME
serverName: str = DEFAULT_SERVER_NAME
serverPort: int = DEFAULT_SERVER_PORT
remoteAddr: str = DEFAULT_REMOTE_ADDR
remoteHost: str = DEFAULT_REMOTE_HOST
locales = list()
secure = False
remotePort: int = DEFAULT_SERVER_PORT
localName: str = DEFAULT_SERVER_NAME
localAddr: str = DEFAULT_SERVER_ADDR
localPort: int = DEFAULT_SERVER_PORT
asyncStarted = False
asyncSupported = False
asyncContext = None
dispatcherType = DispatcherType.REQUEST
# HttpServletRequest properties
authType: str = None
cookies: list = None
headers = defaultdict(set)
method: str = None
pathInfo: str = None
contextPath: str = ""
queryString: str = None
remoteUser: str = None
userRoles = set()
userPrincipal = None # mock
requestedSessionId: str = None
requestURI: str = None
servletPath: str = ""
session = None # mock
requestedSessionIdValid = True
requestedSessionIdFromCookie = True
requestedSessionIdFromURL = True
parts = dict()
def __init__(self,
servletContext=None,
method: str = None,
requestURI: str = None):
if servletContext is None:
self.servletContext = MockServletContext()
else:
self.servletContext = servletContext
self.method = method
self.requestURI = requestURI
self.locales.append(Locale.ENGLISH)
# ---------------------------------------------------------------------
# Lifecycle methods
# ---------------------------------------------------------------------
def get_servlet_context(self):
return self.servletContext
def is_active(self) -> bool:
return self.active
def close(self) -> None:
self.active = False
def invalidate(self) -> None:
self.close()
self.clear_attributes()
def check_active(self) -> None:
assert self.active, "Request is not active anymore"
# ServletRequest interface
def get_attribute(self, name: str):
self.check_active()
return self.attributes.get(name)
def get_attribute_names(self) -> list:
self.check_active()
return list(self.attributes.keys())
def get_character_encoding(self) -> str:
return self.characterEncoding
def set_character_encoding(self, characterEncoding: str) -> None:
self.characterEncoding = characterEncoding
self.update_content_type_header()
def update_content_type_header(self) -> None:
if self.contentType is not None:
value = self.contentType
if (self.characterEncoding
is not None) and (self.CHARSET_PREFIX
not in self.contentType.lower()):
value += f";{self.CHARSET_PREFIX}{self.characterEncoding}"
self.do_add_header_value(HttpHeaders.CONTENT_TYPE, value, True)
def set_content(self, context: bytes) -> None:
self.context = context
self.inputStream = None
self.reader = None
def get_content_as_byte_array(self) -> bytes:
return self.content
def get_content_as_string(self) -> str:
error_msg = """
Cannot get content as a String for a null character encoding.
Consider setting the characterEncoding in the request."
"""
assert self.characterEncoding is not None, error_msg
if self.content is None:
return None
return self.content.decode + self.characterEncoding
def get_content_length(self) -> int:
return -1 if (self.context is None) else len(self.content)
def get_content_length_long(self) -> int:
return self.get_content_length()
def set_content_type(self, contentType: str = None) -> None:
self.contentType = contentType
if contentType is not None:
try:
mediaType = MediaType.parseMediaType(contentType)
if mediaType.getCharset() is not None:
self.characterEncoding = mediaType.getCharset().name()
except Exception:
try:
charsetIndex = contentType.lower().index(
self.CHARSET_PREFIX)
self.characterEncoding = contentType[charsetIndex +
len(self.
CHARSET_PREFIX):]
except Exception:
pass
self.update_content_type_header()
def get_content_type(self) -> str:
return self.contentType
def get_input_stream(self):
if self.inputStream is not None:
return self.inputStream
elif self.reader is not None:
raise ValueError(
"""Cannot call getInputStream() after getReader() has already
been called for the current request""")
if self.content is not None:
self.inputStream = DelegatingServletInputStream(
ByteArrayInputStream(self.content))
else:
self.inputStream = self.EMPTY_SERVLET_INPUT_STREAM
return self.inputStream
def set_parameter(self, name, value) -> None:
if isinstance(name, str):
if isinstance(value, str):
self.parameters[name] = [value]
elif isinstance(value, list):
self.parameters[name] = value
else:
raise ValueError("!!!")
def set_parameters(self, params: dict) -> None:
assert params is not None, "Parameter map must not be null"
for name, value in params.items():
if isinstance(value, str):
self.set_parameter(name, value)
elif isinstance(value, list):
self.set_parameter(name, value)
else:
raise ValueError(f"""Parameter map value must be single value
or array of type [ String ]""")
def add_parameter(self, name, value) -> None:
if isinstance(name, str):
if isinstance(value, str):
self.parameters[name] = [value]
elif isinstance(value, list):
old_value = self.parameters.get(name, [])
self.parameters[name] = old_value + value
else:
raise ValueError("!!!")
def add_parameters(self, params: dict) -> None:
assert params is not None, "Parameter map must not be null"
for name, value in params.items():
if isinstance(value, str):
self.add_parameter(name, value)
elif isinstance(value, list):
self.add_parameter(name, value)
else:
raise ValueError(f"""Parameter map value must be single value
or array of type [ String ]""")
def remove_parameter(self, name: str) -> None:
assert name is not None, "Parameter name must not be null"
self.parameters.pop(name)
def remove_all_parameters(self) -> None:
self.parameters.clear()
def get_parameter(self, name: str) -> None:
assert name is not None, "Parameter name must not be null"
return self.parameters.get(name)
def get_parameter_names(self) -> list:
return list(self.parameters.keys())
def get_parameter_values(self) -> list:
# assert name is not None, "Parameter name must not be null"
return list(self.parameters.values())
def get_parameter_map(self) -> dict:
return self.parameters
def set_protocol(self, protocol: str) -> None:
self.protocol = protocol
def get_protocol(self) -> str:
return self.protocol
def set_scheme(self, scheme: str) -> None:
self.scheme = scheme
def get_scheme(self) -> str:
return self.scheme
def set_server_name(self, serverName: str) -> None:
self.serverName = serverName
def get_server_name(self) -> str:
rawHostHeader: str = self.get_header(HttpHeaders.HOST)
host = rawHostHeader
if host is not None:
host = host.strip()
if host.startswith("["):
assert "]" in host, f"Invalid Host header: {rawHostHeader}"
indexOfClosingBracket = host.index("[")
host = host[:indexOfClosingBracket + 1]
elif ":" in host:
host = host = host[:, host.index(":") + 1]
return host
return self.serverName
def set_server_port(self, serverPort: int) -> None:
self.serverPort = serverPort
def get_server_port(self) -> int:
rawHostHeader: str = self.get_header(HttpHeaders.HOST)
host = rawHostHeader
if host is not None:
host = host.strip()
if host.startswith("["):
assert "]" in host, f"Invalid Host header: {rawHostHeader}"
indexOfClosingBracket = host.index("]")
if ":" in host:
idx = host[indexOfClosingBracket:].index(":")
return host[idx + 1:]
elif ":" in host:
idx = host.index(":")
return host[idx + 1:]
return self.serverPort
def get_reader(self):
if self.reader is not None:
return self.reader
elif self.inputStream is not None:
raise ValueError(
"""Cannot call getReader() after getInputStream() has already
been called for the current request""")
if self.content is not None:
sourceStream = ByteArrayInputStream(self.content)
if self.characterEncoding is not None:
sourceReader = InputStreamReader(sourceStream,
self.characterEncoding)
else:
sourceReader = InputStreamReader(sourceStream)
self.reader = BufferedReader(sourceReader)
else:
self.reader = self.EMPTY_BUFFERED_READER
return self.reader
def set_remote_addr(self, remoteAddr: str):
self.remoteAddr = remoteAddr
def get_remote_addr(self) -> str:
return self.remoteAddr
def set_remote_host(self, remoteHost: str) -> None:
self.remoteHost = remoteHost
def get_remote_host(self) -> str:
return self.remoteHost
def set_attribute(self, name: str, value=None) -> None:
self.check_active()
assert name is not None, "Attribute name must not be null"
if value is not None:
self.attributes[name] = value
else:
self.attributes.pop(name)
def remove_attribute(self, name: str) -> None:
self.check_active()
assert name is not None, "Attribute name must not be null"
self.attributes.pop(name)
def clear_attributes(self) -> None:
self.attributes.clear()
def add_preferred_locale(self, locale: Locale) -> None:
assert locale, "Locale must not be null"
self.locales.append(locale)
self.update_accept_language_header()
def add_preferred_locales(self, locales: list) -> None:
assert locales, "Locale list must not be empty"
self.locales.clear()
self.locales.extend(locales)
self.update_accept_language_header()
def update_accept_language_header(self) -> None:
headers = HttpHeaders()
headers.setAcceptLanguageAsLocales(self.locales)
self.do_add_header_value(
HttpHeaders.ACCEPT_LANGUAGE,
headers.getFirst(HttpHeaders.ACCEPT_LANGUAGE),
True,
)
def get_locale(self):
return self.locales[:1]
def get_locales(self) -> list:
return self.locales
def set_secure(self, secure: bool) -> None:
self.secure = secure
def is_secure(self) -> bool:
return self.secure or self.HTTPS == self.scheme
def get_request_dispatcher(self, path: str):
return MockRequestDispatcher.MockRequestDispatcher(path)
def get_real_path(self, path: str) -> str:
return self.servletContext.getRealPath(path)
def set_remote_port(self, remotePort: int) -> None:
self.remotePort = remotePort
def get_remote_port(self) -> str:
return self.remotePort
def set_local_name(self, localName: str) -> None:
self.localName = localName
def get_local_name(self) -> str:
return self.localName
def set_local_addr(self, localAddr: str) -> None:
self.localAddr = localAddr
def get_local_addr(self) -> str:
return self.localAddr
def set_local_port(self, localPort: int) -> None:
self.localPort = localPort
def get_local_port(self) -> int:
return self.localPort
def start_async(self, request=None, response=None):
request = self is request is None
assert self.asyncSupported, "Async not supported"
self.asyncStarted = True
# TODO
self.asyncContext = MockAsyncContext(request, response)
return self.asyncContext
def set_async_started(self, asyncStarted: bool) -> None:
self.asyncStarted = asyncStarted
def is_async_started(self) -> bool:
return self.asyncStarted
def set_async_supported(self, asyncSupported: bool) -> None:
self.asyncSupported = asyncSupported
def is_async_supported(self) -> bool:
return self.asyncSupported
def set_async_context(self, asyncContext: MockAsyncContext) -> None:
self.asyncContext = asyncContext
def get_async_context(self):
return self.asyncContext
def set_dispatcher_type(self, dispatcherType) -> None:
self.dispatcherType = dispatcherType
def get_dispatcher_type(self):
return self.dispatcherType
# ---------------------------------------------------------------------
# HttpServletRequest interface
# ---------------------------------------------------------------------
def set_auth_type(self, authType: str = None) -> None:
self.authType = authType
def get_auth_type(self) -> str:
return self.authType
def set_cookies(self, cookies: list) -> None:
self.cookies = cookies
if cookies:
self.do_add_header_value(HttpHeaders.COOKIE,
self.encode_cookies(self.cookies), True)
else:
self.remove_header(HttpHeaders.COOKIE)
def encode_cookies(self, cookies: list) -> str:
output = []
for c in cookies:
value = "" if c.getValue() is None else c.getValue()
output.append(f"{c.getName()} = {value}")
return "; ".join(output)
def get_cookies(self) -> list:
return self.cookies
def add_header(self, name: str, value) -> None:
if (HttpHeaders.CONTENT_TYPE == name
and HttpHeaders.CONTENT_TYPE not in self.headers):
self.set_content_type(str(value))
elif (HttpHeaders.ACCEPT_LANGUAGE.equalsIgnoreCase(name)
and HttpHeaders.ACCEPT_LANGUAGE not in self.headers):
try:
headers = HttpHeaders()
headers.add(HttpHeaders.ACCEPT_LANGUAGE, str())
locales: list = headers.getAcceptLanguageAsLocales()
self.locales.clear()
self.locales.extend(locales)
if not locales:
locales.append(Locale.ENGLISH)
except Exception:
# Invalid Accept-Language format -> just store plain header
pass
self.do_add_header_value(name, value, True)
else:
self.do_add_header_value(name, value, False)
def do_add_header_value(self, name: str, value, replace: bool) -> None:
header: HeaderValueHolder = self.headers.get(name)
assert value is not None, "Header value must not be null"
if header is None or replace:
header = HeaderValueHolder()
self.header[name] = header
if isinstance(value, set):
header.update(value)
elif isinstance(value, list):
header.update(set(value))
else:
header.add(value)
def remove_header(self, name: str) -> None:
assert name is not None, "Header name must not be null"
self.headers.remove(name)
def get_date_header(self, name: str) -> int:
header: HeaderValueHolder = self.headers.get(name)
value = None if header is None else header.getValue()
if isinstance(value, datetime):
return datetime.timestamp()
elif isinstance(value, (int, float)):
return value
elif isinstance(value, str):
return self.parse_date_header(name, value)
elif value is not None:
raise ValueError(f"""Value for header '{name}' + is not a Date,
Number, or String: {value}""")
else:
return -1
def parse_date_header(self, name: str, value: str) -> int:
for dateFormat in self.DATE_FORMATS:
try:
date = datetime.strptime(value, dateFormat)
date = date.replace(tzinfo=self.GMT)
return date.timestamp()
except Exception:
pass
raise ValueError(
f"""Cannot parse date value '{value}' for '{name}' header""")
def get_header(self, name: str) -> str:
header: HeaderValueHolder = self.headers.get(name)
return None if header is None else header.__str__()
def get_headers(self, name: str) -> list:
header: HeaderValueHolder = self.headers.get(name)
return [i.__str__() for i in header]
def get_header_names(self) -> list:
return list(self.headers.key())
def get_int_header(self, name: str) -> int:
header: HeaderValueHolder = self.headers.get(name)
value = None if header is None else header.getValue()
if isinstance(value, (int, float, str)):
return int(value)
elif value is not None:
raise ValueError(
f"Value for header '{name}' is not a Number: {value}")
else:
return -1
def set_method(self, method: str = None) -> None:
self.method = method
def get_method(self) -> str:
return self.method
def set_path_info(self, pathInfo: str) -> None:
self.pathInfo = pathInfo
def get_path_info(self) -> str:
return self.pathInfo
def get_path_translated(self):
if self.pathInfo is None:
return None
else:
return self.get_real_path(self.pathInfo)
def set_context_path(self, contextPath: str) -> None:
self.contextPath = contextPath
def get_context_path(self) -> str:
return self.contextPath
def set_request_uri(self, requestURI: str) -> None:
self.requestURI = requestURI
def get_request_uri(self) -> str:
return self.requestURI
def set_query_string(self, queryString: str = None) -> None:
self.queryString = queryString
def get_query_string(self) -> str:
return self.queryString
def set_remote_user(self, remoteUser: str = None) -> None:
self.remoteUser = remoteUser
def get_remote_user(self) -> str:
return self.remoteUser
def add_user_role(self, role: str) -> None:
self.userRoles.add(role)
def is_user_in_role(self, role: str) -> bool:
return role in self.userRoles or (
isinstance(MockServletContext, self.servletContext)
and self.servletContext.getDeclaredRoles().contains(role))
def set_user_principal(self, userPrincipal=None) -> None:
self.userPrincipal = userPrincipal
def get_user_principal(self):
return self.userPrincipal
def set_requested_session_id(self, requestedSessionId: str = None):
self.requestedSessionId = requestedSessionId
def get_requested_session_id(self) -> str:
return self.requestedSessionId
def set_request_uri(self, requestURI: str = None) -> None:
self.requestURI = requestURI
def get_request_uri(self) -> str:
return self.requestURI
def get_request_url(self) -> str:
scheme = self.get_scheme()
server = self.get_server_name()
port = self.get_server_port()
uri = self.get_request_uri()
url = scheme + "://" + server
if (port > 0 and
(self.HTTP.casefold() == scheme.casefold() and port != 80) or
(self.HTTPS.casefold() == scheme.casefold() and port != 443)):
url += f":{port}"
if uri:
url += uri
return url
def set_servlet_path(self, servletPath: str) -> None:
self.servletPath = servletPath
def get_servlet_path(self) -> str:
return self.servletPath
# return type HttpSession
def set_session(self, session):
self.session = session
if isinstance(session, MockHttpSession):
session.access()
def get_session(self, create: bool = True):
self.check_active()
if (isinstance(self.session, MockHttpSession)
and self.session.isInvalid()):
self.session = None
if self.session is None and create:
self.session = MockHttpSession(self.servletContext)
return self.session
def change_session_id(self) -> str:
assert self.session is not None, "The request does not have a session"
if isinstance(self.session, MockHttpSession):
return self.session.changeSessionId()
return self.session.getId()
def set_requested_session_id_valid(self,
requestedSessionIdValid: bool) -> None:
self.requestedSessionIdValid = requestedSessionIdValid
def is_requested_session_id_valid(self) -> bool:
return self.isRequestedSessionIdValid
def set_requested_session_id_from_cookie(
self, requestedSessionIdFromCookie) -> None:
self.requestedSessionIdFromCookie = requestedSessionIdFromCookie
def is_requested_session_id_from_cookie(self) -> bool:
return self.isRequestedSessionIdFromCookie
def set_requested_session_id_from_url(
self, requestedSessionIdFromURL: bool) -> None:
self.requestedSessionIdFromURL = requestedSessionIdFromURL
def is_requested_session_id_from_url(self) -> bool:
return self.requestedSessionIdFromURL
def authenticate(self, response) -> bool:
raise ValueError("UnsupportedOperationException")
def logout(self) -> None:
self.userPrincipal = None
self.remoteUser = None
self.authType = None
def add_part(self, part) -> None:
self.parts.add(part.getName(), part)
# return type Part
def get_part(self, name: str):
tmp = list(self.parts.keys())
if tmp:
return tmp[0]
return None
def get_parts(self) -> set:
result = []
for part_list in self.parts.values():
result.extend(part_list)
return result
def upgrade(self):
raise ValueError("UnsupportedOperationException")
def setUp(self):
self.wac = StaticWebApplicationContext()
self.sc = MockServletContext()
self.request = MockHttpServletRequest()
self.response = MockHttpServletResponse()
self.wac.set_servlet_context(self.sc)
def __init__(self, servletContext=None, servletName: str = ""):
self.servletName = servletName
if servletContext is None:
self.servletContext = MockServletContext()
else:
self.servletContext = servletContext