/**
* Simulates the use case when the {@code HttpServletResponse.encodeURL()} changes the context
* path.
*/
public void testStripContextPathFromURLWhenOutBoundRewriteRuleChangingContextPath()
throws Exception {
this.mockXWiki.stubs().method("getWebAppPath").will(returnValue("xwiki/"));
Mock xwikiResponse = mock(XWikiResponse.class);
xwikiResponse.stubs().method("setLocale");
xwikiResponse
.stubs()
.method("encodeURL")
.will(
new CustomStub("Implements XWikiResponse.encodeURL") {
@Override
public Object invoke(Invocation invocation) throws Throwable {
return "http://localhost:8080/anothercontext"
+ ";jsessionid=0AF95AFB8997826B936C0397DF6A0C7F?language=en";
}
});
getContext().setResponse((XWikiResponse) xwikiResponse.proxy());
// Note: the passed URL to stripContextPathFromURL() has also gone through encodeURL() which is
// why its
// context path has been changed from "xwiki" to "anothercontext".
assertEquals(
"/something",
this.authService.stripContextPathFromURL(
new URL("http://localhost:8080/anothercontext/something"), getContext()));
}
/**
* Test that SomeUser is correctly authenticated as XWiki.SomeUser when xwiki:SomeUser is entered
* as username.
*/
public void testLoginWithWikiPrefix() throws Exception {
// Setup a simple user profile document
XWikiDocument userDoc = new XWikiDocument("XWiki", "SomeUser");
// Mock the XWikiUsers object, since a real objects requires more mocking on the XWiki object
Mock mockUserObj = mock(BaseObject.class, new Class[] {}, new Object[] {});
mockUserObj.stubs().method("setDocumentReference");
mockUserObj.stubs().method("setNumber");
mockUserObj.stubs().method("getStringValue").with(eq("password")).will(returnValue("pass"));
mockUserObj.stubs().method("setOwnerDocument");
userDoc.addObject("XWiki.XWikiUsers", (BaseObject) mockUserObj.proxy());
// Make a simple XWiki.XWikiUsers class that will contain a default password field
BaseClass userClass = new BaseClass();
userClass.addPasswordField("password", "Password", 20);
userClass.setClassName("XWiki.XWikiUsers");
// Prepare the XWiki mock
this.mockXWiki
.stubs()
.method("getDocument")
.with(eq("XWiki.SomeUser"), eq(this.getContext()))
.will(returnValue(userDoc));
this.mockXWiki
.stubs()
.method("getClass")
.with(eq("XWiki.XWikiUsers"), eq(this.getContext()))
.will(returnValue(userClass));
this.mockXWiki.stubs().method("exists").will(returnValue(true));
// Finally run the test: Using xwiki:Admin should correctly authenticate the Admin user
Principal principal =
this.authService.authenticate("xwiki:SomeUser", "pass", this.getContext());
assertNotNull(principal);
assertEquals("xwiki:XWiki.SomeUser", principal.getName());
}
/** See XWIKI-5277 for details. */
public void testGetRenderedContentCleansVelocityMacroCache() throws Exception {
// Make sure we start not in the rendering engine since this is what happens in real: a document
// is
// called by a template thus outside of the rendering engine.
getContext().remove("isInRenderingEngine");
// We display a text area since we know that rendering a text area will call getRenderedContent
// inside our top
// level getRenderedContent call, thus testing that velocity macros are not removed during
// nested calls to
// getRenderedContent.
this.baseObject.setLargeStringValue(
"area", "{{velocity}}#macro(testmacrocache)ok#end{{/velocity}}");
this.document.setContent("{{velocity}}$doc.display(\"area\")#testmacrocache{{/velocity}}");
this.document.setSyntax(Syntax.XWIKI_2_0);
// We need to put the current doc in the Velocity Context since it's normally set before the
// rendering is
// called in the execution flow.
VelocityManager originalVelocityManager = getComponentManager().lookup(VelocityManager.class);
VelocityContext vcontext = originalVelocityManager.getVelocityContext();
vcontext.put("doc", new Document(this.document, getContext()));
// Register a Mock for the VelocityManager to bypass skin APIs that we would need to mock
// otherwise.
Mock mockVelocityManager = registerMockComponent(VelocityManager.class);
mockVelocityManager.stubs().method("getVelocityContext").will(returnValue(vcontext));
VelocityEngine vengine =
getComponentManager()
.lookup(VelocityFactory.class)
.createVelocityEngine("default", new Properties());
// Save the number of cached macro templates in the Velocity engine so that we can compare after
// the
// document is rendered.
JMXVelocityEngineMBean mbean = new JMXVelocityEngine(vengine);
int cachedMacroNamespaceSize = mbean.getTemplates().values().size();
assertTrue(cachedMacroNamespaceSize > 0);
mockVelocityManager.stubs().method("getVelocityEngine").will(returnValue(vengine));
// $doc.display will ask for the syntax of the current document so we need to mock it.
this.mockXWiki
.stubs()
.method("getCurrentContentSyntaxId")
.with(eq("xwiki/2.0"), ANYTHING)
.will(returnValue("xwiki/2.0"));
// Verify that the macro located inside the TextArea has been taken into account when executing
// the doc's
// content.
assertEquals("<p>ok</p>", this.document.getRenderedContent(getContext()));
// Now verify that the Velocity Engine doesn't contain any more cached macro namespace to prove
// that
// getRenderedContent has correctly cleaned the Velocity macro cache.
assertEquals(cachedMacroNamespaceSize, mbean.getTemplates().values().size());
}
protected void setUp() throws Exception {
super.setUp();
mockRequest = mock(HttpServletRequest.class);
mockRequest
.stubs()
.method("getParameterNames")
.will(returnValue(new Vector<String>().elements()));
mockRequest.stubs().method("getRequestURI").will(returnValue("/YourRhn.do"));
}
@Override
protected void registerComponents() throws Exception {
super.registerComponents();
// Setup display configuration.
Mock mockDisplayConfiguration = registerMockComponent(DisplayConfiguration.class);
mockDisplayConfiguration
.stubs()
.method("getDocumentDisplayerHint")
.will(returnValue("default"));
mockDisplayConfiguration.stubs().method("getTitleHeadingDepth").will(returnValue(2));
}
protected void setUp() throws Exception {
super.setUp();
getContext().setDoc(new XWikiDocument());
XWiki xwiki = new XWiki();
Mock mockXWikiStore =
mock(
XWikiHibernateStore.class,
new Class[] {XWiki.class, XWikiContext.class},
new Object[] {xwiki, getContext()});
xwiki.setStore((XWikiStoreInterface) mockXWikiStore.proxy());
Mock mockXWikiRenderingEngine = mock(XWikiRenderingEngine.class);
mockXWikiRenderingEngine
.stubs()
.method("interpretText")
.will(
new CustomStub("Implements XWikiRenderingEngine.interpretText") {
public Object invoke(Invocation invocation) throws Throwable {
return invocation.parameterValues.get(0);
}
});
xwiki.setRenderingEngine((XWikiRenderingEngine) mockXWikiRenderingEngine.proxy());
getContext().setWiki(xwiki);
}
public void testHJBConnectionSetsExceptionListenerOnConstruction() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
Connection testConnection = (Connection) mockConnection.proxy();
new HJBConnection(testConnection, 0);
}
public void testGetActionWhenActionsContainerAlreadyExists() {
MutablePicoContainer requestContainer = new DefaultPicoContainer();
requestContainer.registerComponentInstance(TestService.class, service);
MutablePicoContainer actionsContainer = new DefaultPicoContainer(requestContainer);
requestMock
.stubs()
.method("getAttribute")
.with(eq(KeyConstants.ACTIONS_CONTAINER))
.will(returnValue(actionsContainer));
StrutsTestAction action1 =
(StrutsTestAction) actionFactory.getAction(request, mapping1, servlet);
StrutsTestAction action2 =
(StrutsTestAction) actionFactory.getAction(request, mapping2, servlet);
TestAction action3 = (TestAction) actionFactory.getAction(request, mapping1, servlet);
TestAction action4 = (TestAction) actionFactory.getAction(request, mapping2, servlet);
assertNotNull(action1);
assertNotNull(action2);
assertNotSame(action1, action2);
assertSame(action1, action3);
assertSame(action2, action4);
assertSame(action1, actionsContainer.getComponentInstance("/myPath1"));
assertSame(action2, actionsContainer.getComponentInstance("/myPath2"));
assertSame(service, action1.getService());
assertSame(service, action2.getService());
assertNotNull(action1.getServlet());
assertNotNull(action2.getServlet());
assertSame(servlet, action1.getServlet());
assertSame(servlet, action2.getServlet());
}
protected void setUp() {
String actionType = StrutsTestAction.class.getName();
mapping1 = new ActionMapping();
mapping1.setPath("/myPath1");
mapping1.setType(actionType);
mapping2 = new ActionMapping();
mapping2.setPath("/myPath2");
mapping2.setType(actionType);
requestMock.stubs().method("getSession").will(returnValue(session));
sessionMock.stubs().method("getServletContext").will(returnValue(servletContext));
actionFactory = new ActionFactory();
service = new TestService();
}
public void testMBeanInfoIsDeterminedIfKeyIsType() {
final PersonMBean person = new OtherPerson();
final Mock mockComponentAdapter = mock(ComponentAdapter.class);
mockComponentAdapter.stubs().method("getComponentKey").will(returnValue(Person.class));
mockComponentAdapter
.stubs()
.method("getComponentImplementation")
.will(returnValue(person.getClass()));
pico.addAdapter((ComponentAdapter) mockComponentAdapter.proxy());
pico.addComponent(Person.class.getName() + "MBeanInfo", Person.createMBeanInfo());
final MBeanInfo info =
mBeanProvider.provide(pico, (ComponentAdapter) mockComponentAdapter.proxy());
assertNotNull(info);
assertEquals(Person.createMBeanInfo().getDescription(), info.getDescription());
}
public void testStopInvokesDecorateeConnection() throws Exception {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection.expects(once()).method("stop");
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
h.stop();
}
private void injectMockAppContextTo(KeywordBeanLoader beanLoader) {
appContext.stubs();
appContext.expects(once()).method("refresh");
appContext
.expects(once())
.method("getBeansOfType")
.with(eq(Object.class))
.will(returnValue(keywordBeans));
beanLoader.context = (GenericApplicationContext) appContext.proxy();
}
public void testCreateSessionInvokesDecorateeConnection() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection.expects(once()).method("createSession");
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
h.createSession(true, 1);
}
public void testSetExceptionListenerNeverInvokesDecorateeConnection() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
h.setExceptionListener(null);
h.setExceptionListener(null);
}
public final void testExecuteWhenRequestHasNoParams() throws Exception {
mockRequest
.stubs()
.method("getParameterNames")
.will(returnValue(new Vector<String>().elements()));
CreateRedirectURI command = new CreateRedirectURI();
String redirectUrl = command.execute(getMockRequest());
assertEquals("/YourRhn.do?", redirectUrl);
}
public final void testExecuteWhenRedirectURIExceedsMaxLength() throws Exception {
String url =
StringUtils.rightPad("/YourRhn.do", (int) CreateRedirectURI.MAX_URL_LENGTH + 1, "x");
mockRequest.stubs().method("getRequestURI").will(returnValue(url));
CreateRedirectURI command = new CreateRedirectURI();
String redirectUrl = command.execute(getMockRequest());
assertEquals(LoginAction.DEFAULT_URL_BOUNCE, redirectUrl);
}
public void testAutomaticallyNamesTextFieldWithoutName() {
textField.setName(null);
new JFrame().getContentPane().add(textField);
mockRecorder
.expects(once())
.method("record")
.with(eq(new EnterTextEvent("JTextField_1", "abc")));
recorder.componentShown(textField);
mockVisibility.stubs().method("isShowingAndHasFocus").will(returnValue(true));
textField.setText("abc");
}
public void testGetSessions() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection.expects(atLeastOnce()).method("createSession");
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
h.createSession(true, 1);
assertEquals("1 session should have been added", 1, h.getActiveSessions().size());
h.createSession(true, 1);
assertEquals("2 sessions should have been added", 2, h.getActiveSessions().size());
}
public void testCreateDurableConnectionConsumerAlwaysThrowsHJBException() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection.expects(never()).method("createDurableConnectionConsumer");
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
try {
h.createDurableConnectionConsumer(null, null, null, null, 0);
fail("An HJBException should have been thrown");
} catch (HJBException e) {
}
}
@Test
public void pluginRegistersWithServer() {
Mock mockServer = mock(SBuildServer.class);
mockServer.expects(once()).method("addListener");
Mock mockPluginDescriptor = mock(PluginDescriptor.class);
mockPluginDescriptor.stubs();
SBuildServer server = (SBuildServer) mockServer.proxy();
PluginDescriptor descriptor = (PluginDescriptor) mockPluginDescriptor.proxy();
ExampleServerPlugin plugin = new ExampleServerPlugin(server, descriptor);
plugin.register();
verify();
}
public void testEnteringTextPostsEnterEvent() {
mockRecorder
.expects(once())
.method("record")
.with(eq(new EnterTextEvent("testTextField", "abc")));
recorder.componentShown(textField);
mockVisibility.stubs().method("isShowingAndHasFocus").will(returnValue(true));
textField.setText("abc");
mockRecorder.expects(once()).method("record").with(eq(new EnterTextEvent("testTextField", "")));
mockRecorder
.expects(once())
.method("record")
.with(eq(new EnterTextEvent("testTextField", "def")));
textField.setText("def");
}
public void testBadActionType() {
MutablePicoContainer actionsContainer = new DefaultPicoContainer();
requestMock
.stubs()
.method("getAttribute")
.with(eq(KeyConstants.ACTIONS_CONTAINER))
.will(returnValue(actionsContainer));
mapping1.setType("/i/made/a/typo");
try {
actionFactory.getAction(request, mapping1, servlet);
fail("PicoIntrospectionException should have been raised");
} catch (PicoIntrospectionException e) {
// expected
}
}
public final void testExecuteWhenRequestHasParams() throws Exception {
String paramName = "foo";
String paramValue = "param value = bar#$%!";
String expected = "/YourRhn.do?foo=" + URLEncoder.encode(paramValue, "UTF-8") + "&";
Vector<String> paramNames = new Vector<String>();
paramNames.add(paramName);
mockRequest.stubs().method("getParameterNames").will(returnValue(paramNames.elements()));
mockRequest.stubs().method("getParameter").with(eq(paramName)).will(returnValue(paramValue));
CreateRedirectURI command = new CreateRedirectURI();
String redirectURI = command.execute(getMockRequest());
assertEquals(expected, redirectURI);
}
public void testClosePropagatesJMSException() throws Exception {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection
.expects(once())
.method("close")
.will(throwException(new JMSException("thrown as test")));
Connection testConnection = (Connection) mockConnection.proxy();
HJBConnection h = new HJBConnection(testConnection, 0);
try {
h.close();
fail("A JMSException should have been thrown");
} catch (JMSException e) {
}
}
public void testCreateSessionThrowsHJBExceptionOnJMSException() {
Mock mockConnection = connectionBuilder.createMockConnection();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection
.expects(once())
.method("createSession")
.will(throwException(new JMSException("thrown as a test")));
Connection testConnection = (Connection) mockConnection.proxy();
try {
HJBConnection h = new HJBConnection(testConnection, 0);
h.createSession(true, 1);
fail("An HJBException should have been thrown");
} catch (HJBException e) {
}
}
public void testStripContextPathFromURLWhenRootWebAppAndJSessionId() throws Exception {
this.mockXWiki.stubs().method("getWebAppPath").will(returnValue(""));
// Simulate a rewrite filter that would add a jsession id and add a leading slash!
Mock xwikiResponse = mock(XWikiResponse.class);
xwikiResponse
.stubs()
.method("encodeURL")
.with(eq("http://localhost:8080"))
.will(
new CustomStub("Implements XWikiResponse.encodeURL") {
@Override
public Object invoke(Invocation invocation) throws Throwable {
return "http://localhost:8080/;jsessionid=0AF95AFB8997826B936C0397DF6A0C7F";
}
});
getContext().setResponse((XWikiResponse) xwikiResponse.proxy());
assertEquals(
"/something",
this.authService.stripContextPathFromURL(
new URL("http://localhost:8080/something"), getContext()));
}
public void testCreateSessionAddsANewCommandRunner() {
Mock mockConnection = connectionBuilder.createMockConnection();
Connection testConnection = (Connection) mockConnection.proxy();
registerToVerify(mockConnection);
mockConnection.stubs().method("setExceptionListener");
mockConnection.expects(once()).method("createSession");
HJBConnection h = new HJBConnection(testConnection, 0);
try {
h.getSessionCommandRunner(0);
fail("should throw exception");
} catch (IndexOutOfBoundsException e) {
}
h.createSession(true, 1);
assertNotNull("should exist", h.getSessionCommandRunner(0));
try {
h.getSessionCommandRunner(1);
fail("should throw exception");
} catch (IndexOutOfBoundsException e) {
}
h.createSession(true, 1);
assertNotNull("should exist", h.getSessionCommandRunner(1));
}
/**
* {@inheritDoc}
*
* @see junit.framework.TestCase#setUp()
*/
@Override
protected void setUp() throws Exception {
super.setUp();
this.databases.put(MAIN_WIKI_NAME, new HashMap<String, XWikiDocument>());
XWiki xwiki =
new XWiki() {
public XWikiDocument getDocument(String fullname, XWikiContext context)
throws XWikiException {
return XWikiServletURLFactoryTest.this.getDocument(
Utils.getComponent(DocumentReferenceResolver.class, "currentmixed")
.resolve(fullname));
}
public XWikiDocument getDocument(
DocumentReference documentReference, XWikiContext context) throws XWikiException {
return XWikiServletURLFactoryTest.this.getDocument(documentReference);
}
public String getXWikiPreference(
String prefname, String defaultValue, XWikiContext context) {
return defaultValue;
}
protected void registerWikiMacros() {}
};
xwiki.setConfig((this.config = new XWikiConfig()));
xwiki.setDatabase(getContext().getDatabase());
Mock mockXWikiRequest = mock(XWikiRequest.class, new Class[] {}, new Object[] {});
mockXWikiRequest.stubs().method("getScheme").will(returnValue("http"));
mockXWikiRequest
.stubs()
.method("isSecure")
.will(
new CustomStub("Implements ServletRequest.isSecure") {
public Object invoke(Invocation invocation) throws Throwable {
return secure;
}
});
mockXWikiRequest.stubs().method("getServletPath").will(returnValue(""));
mockXWikiRequest.stubs().method("getContextPath").will(returnValue("/xwiki"));
mockXWikiRequest
.stubs()
.method("getHeader")
.will(
new CustomStub("Implements HttpServletRequest.getHeader") {
public Object invoke(Invocation invocation) throws Throwable {
String headerName = (String) invocation.parameterValues.get(0);
return httpHeaders.get(headerName);
}
});
getContext().setWiki(xwiki);
getContext().setRequest((XWikiRequest) mockXWikiRequest.proxy());
// Create sub-wikis.
createWiki("wiki1");
createWiki("wiki2");
getContext().setURL(new URL("http://127.0.0.1/xwiki/view/InitialSpace/InitialPage"));
this.urlFactory.init(getContext());
}
/**
* {@inheritDoc}
*
* @see com.xpn.xwiki.test.AbstractBridgedXWikiComponentTestCase#setUp()
*/
@Override
protected void setUp() throws Exception {
super.setUp();
XWikiConfig config = new XWikiConfig();
Mock mockServletContext = mock(ServletContext.class);
ByteArrayInputStream bais =
new ByteArrayInputStream("code=wiki:code:type:content".getBytes("UTF-8"));
mockServletContext
.stubs()
.method("getResourceAsStream")
.with(eq("/templates/macros.txt"))
.will(returnValue(bais));
mockServletContext
.stubs()
.method("getResourceAsStream")
.with(eq("/WEB-INF/oscache.properties"))
.will(returnValue(new ByteArrayInputStream("".getBytes("UTF-8"))));
mockServletContext
.stubs()
.method("getResourceAsStream")
.with(eq("/WEB-INF/oscache-local.properties"))
.will(returnValue(new ByteArrayInputStream("".getBytes("UTF-8"))));
XWikiServletContext engineContext =
new XWikiServletContext((ServletContext) mockServletContext.proxy());
xwiki =
new XWiki(config, getContext(), engineContext, false) {
public String getSkin(XWikiContext context) {
return "skin";
}
public String getXWikiPreference(
String prefname, String defaultValue, XWikiContext context) {
return defaultValue;
}
public String getSpacePreference(
String prefname, String defaultValue, XWikiContext context) {
return defaultValue;
}
protected void registerWikiMacros() {}
public XWikiRightService getRightService() {
return new XWikiRightServiceImpl() {
public boolean hasProgrammingRights(XWikiDocument doc, XWikiContext context) {
return true;
}
};
}
};
xwiki.setVersion("1.0");
// Ensure that no Velocity Templates are going to be used when executing Velocity since
// otherwise
// the Velocity init would fail (since by default the macros.vm templates wouldn't be found as
// we're
// not providing it in our unit test resources).
xwiki.getConfig().setProperty("xwiki.render.velocity.macrolist", "");
this.engine = (DefaultXWikiRenderingEngine) xwiki.getRenderingEngine();
// Make sure the wiki in the context will say that we have programming permission.
getContext().setWiki(this.xwiki);
}