Search in sources :

Example 6 with QueryManager

use of org.xwiki.query.QueryManager in project xwiki-platform by xwiki.

the class MessageStreamTest method testGetRecentPersonalMessagesWhenQueryFails.

@Test
public void testGetRecentPersonalMessagesWhenQueryFails() throws Exception {
    final Query mockQuery = getMockQuery();
    final QueryManager mockQueryManager = getComponentManager().getInstance(QueryManager.class);
    final EventStream mockEventStream = getComponentManager().getInstance(EventStream.class);
    final DocumentAccessBridge mockBridge = getComponentManager().getInstance(DocumentAccessBridge.class);
    final EntityReferenceSerializer<String> mockSerializer = getComponentManager().getInstance(EntityReferenceSerializer.TYPE_STRING);
    getMockery().checking(new Expectations() {

        {
            allowing(mockBridge).getCurrentUserReference();
            will(returnValue(MessageStreamTest.this.currentUser));
            allowing(mockSerializer).serialize(MessageStreamTest.this.currentUser);
            will(returnValue("wiki:XWiki.JohnDoe"));
            exactly(1).of(mockQuery).setLimit(30);
            will(returnValue(mockQuery));
            exactly(1).of(mockQuery).setOffset(0);
            will(returnValue(mockQuery));
            allowing(mockQuery).bindValue(with(any(String.class)), with("wiki:XWiki.JohnDoe"));
            allowing(mockQueryManager).createQuery(with(aNonNull(String.class)), with(aNonNull(String.class)));
            will(returnValue(mockQuery));
            exactly(1).of(mockEventStream).searchEvents(with(mockQuery));
            will(throwException(new QueryException("", null, null)));
        }
    });
    List<Event> result = this.stream.getRecentPersonalMessages();
    Assert.assertNotNull(result);
    Assert.assertTrue(result.isEmpty());
}
Also used : Expectations(org.jmock.Expectations) QueryException(org.xwiki.query.QueryException) Query(org.xwiki.query.Query) EventStream(org.xwiki.eventstream.EventStream) QueryManager(org.xwiki.query.QueryManager) DocumentAccessBridge(org.xwiki.bridge.DocumentAccessBridge) Event(org.xwiki.eventstream.Event) DefaultEvent(org.xwiki.eventstream.internal.DefaultEvent) Test(org.junit.Test)

Example 7 with QueryManager

use of org.xwiki.query.QueryManager in project xwiki-platform by xwiki.

the class DefaultModelBridgeTest method getDocumentReferences.

@Test
public void getDocumentReferences() throws Exception {
    SpaceReference spaceReference = new SpaceReference("wiki", "Space");
    Query query = mock(Query.class);
    QueryManager queryManager = this.mocker.getInstance(QueryManager.class);
    when(queryManager.createQuery(any(), any())).thenReturn(query);
    EntityReferenceSerializer<String> localEntityReferenceSerializer = this.mocker.getInstance(EntityReferenceSerializer.TYPE_STRING, "local");
    when(localEntityReferenceSerializer.serialize(spaceReference)).thenReturn("Space");
    when(query.execute()).thenReturn(Arrays.<Object>asList("Page"));
    DocumentReferenceResolver<String> explicitDocumentReferenceResolver = this.mocker.getInstance(DocumentReferenceResolver.TYPE_STRING, "explicit");
    DocumentReference documentReference = new DocumentReference("Page", spaceReference);
    when(explicitDocumentReferenceResolver.resolve("Page", spaceReference)).thenReturn(documentReference);
    assertEquals(Arrays.asList(documentReference), this.mocker.getComponentUnderTest().getDocumentReferences(spaceReference));
    verify(query).setWiki(spaceReference.getWikiReference().getName());
    verify(query).bindValue("space", "Space");
    verify(query).bindValue("spacePrefix", "Space.%");
}
Also used : Query(org.xwiki.query.Query) SpaceReference(org.xwiki.model.reference.SpaceReference) QueryManager(org.xwiki.query.QueryManager) ArgumentMatchers.anyString(org.mockito.ArgumentMatchers.anyString) DocumentReference(org.xwiki.model.reference.DocumentReference) Test(org.junit.Test)

Example 8 with QueryManager

use of org.xwiki.query.QueryManager in project xwiki-platform by xwiki.

the class MockitoOldcore method before.

public void before(Class<?> testClass) throws Exception {
    // Statically store the component manager in {@link Utils} to be able to access it without
    // the context.
    Utils.setComponentManager(getMocker());
    this.context = new XWikiContext();
    getXWikiContext().setWikiId("xwiki");
    getXWikiContext().setMainXWiki("xwiki");
    this.spyXWiki = spy(new XWiki());
    getXWikiContext().setWiki(this.spyXWiki);
    this.mockHibernateStore = mock(XWikiHibernateStore.class);
    this.mockVersioningStore = mock(XWikiVersioningStoreInterface.class);
    this.mockRightService = mock(XWikiRightService.class);
    this.mockGroupService = mock(XWikiGroupService.class);
    doReturn(this.mockHibernateStore).when(this.spyXWiki).getStore();
    doReturn(this.mockHibernateStore).when(this.spyXWiki).getHibernateStore();
    doReturn(this.mockVersioningStore).when(this.spyXWiki).getVersioningStore();
    doReturn(this.mockRightService).when(this.spyXWiki).getRightService();
    doReturn(this.mockGroupService).when(this.spyXWiki).getGroupService(getXWikiContext());
    // We need to initialize the Component Manager so that the components can be looked up
    getXWikiContext().put(ComponentManager.class.getName(), getMocker());
    if (testClass.getAnnotation(AllComponents.class) != null) {
        // If @AllComponents is enabled force mocking AuthorizationManager and ContextualAuthorizationManager if not
        // already mocked
        this.mockAuthorizationManager = getMocker().registerMockComponent(AuthorizationManager.class, false);
        this.mockContextualAuthorizationManager = getMocker().registerMockComponent(ContextualAuthorizationManager.class, false);
    } else {
        // Make sure an AuthorizationManager and a ContextualAuthorizationManager is available
        if (!getMocker().hasComponent(AuthorizationManager.class)) {
            this.mockAuthorizationManager = getMocker().registerMockComponent(AuthorizationManager.class);
        }
        if (!getMocker().hasComponent(ContextualAuthorizationManager.class)) {
            this.mockContextualAuthorizationManager = getMocker().registerMockComponent(ContextualAuthorizationManager.class);
        }
    }
    // Make sure a default ConfigurationSource is available
    if (!getMocker().hasComponent(ConfigurationSource.class)) {
        this.configurationSource = getMocker().registerMemoryConfigurationSource();
    }
    // Make sure a "xwikicfg" ConfigurationSource is available
    if (!getMocker().hasComponent(ConfigurationSource.class, XWikiCfgConfigurationSource.ROLEHINT)) {
        this.xwikicfgConfigurationSource = new MockConfigurationSource();
        getMocker().registerComponent(MockConfigurationSource.getDescriptor(XWikiCfgConfigurationSource.ROLEHINT), this.xwikicfgConfigurationSource);
    }
    // Make sure a "wiki" ConfigurationSource is available
    if (!getMocker().hasComponent(ConfigurationSource.class, "wiki")) {
        this.wikiConfigurationSource = new MockConfigurationSource();
        getMocker().registerComponent(MockConfigurationSource.getDescriptor("wiki"), this.wikiConfigurationSource);
    }
    // Make sure a "space" ConfigurationSource is available
    if (!getMocker().hasComponent(ConfigurationSource.class, "space")) {
        this.spaceConfigurationSource = new MockConfigurationSource();
        getMocker().registerComponent(MockConfigurationSource.getDescriptor("space"), this.spaceConfigurationSource);
    }
    // correctly with a Servlet Context.
    if (getMocker().hasComponent(Environment.class) && getMocker().getInstance(Environment.class) instanceof ServletEnvironment) {
        ServletEnvironment environment = getMocker().getInstance(Environment.class);
        ServletContext servletContextMock = mock(ServletContext.class);
        environment.setServletContext(servletContextMock);
        when(servletContextMock.getAttribute("javax.servlet.context.tempdir")).thenReturn(new File(System.getProperty("java.io.tmpdir")));
        File testDirectory = new File("target/test-" + new Date().getTime());
        this.temporaryDirectory = new File(testDirectory, "temporary-dir");
        this.permanentDirectory = new File(testDirectory, "permanent-dir");
        environment.setTemporaryDirectory(this.temporaryDirectory);
        environment.setPermanentDirectory(this.permanentDirectory);
    }
    // Initialize the Execution Context
    if (this.componentManager.hasComponent(ExecutionContextManager.class)) {
        ExecutionContextManager ecm = this.componentManager.getInstance(ExecutionContextManager.class);
        ExecutionContext ec = new ExecutionContext();
        ecm.initialize(ec);
    }
    // Bridge with old XWiki Context, required for old code.
    Execution execution;
    if (this.componentManager.hasComponent(Execution.class)) {
        execution = this.componentManager.getInstance(Execution.class);
    } else {
        execution = this.componentManager.registerMockComponent(Execution.class);
    }
    ExecutionContext econtext;
    if (MockUtil.isMock(execution)) {
        econtext = new ExecutionContext();
        when(execution.getContext()).thenReturn(econtext);
    } else {
        econtext = execution.getContext();
    }
    // Set a few standard things in the ExecutionContext
    econtext.setProperty(XWikiContext.EXECUTIONCONTEXT_KEY, this.context);
    this.scriptContext = (ScriptContext) econtext.getProperty(ScriptExecutionContextInitializer.SCRIPT_CONTEXT_ID);
    if (this.scriptContext == null) {
        this.scriptContext = new SimpleScriptContext();
        econtext.setProperty(ScriptExecutionContextInitializer.SCRIPT_CONTEXT_ID, this.scriptContext);
    }
    if (!this.componentManager.hasComponent(ScriptContextManager.class)) {
        ScriptContextManager scriptContextManager = this.componentManager.registerMockComponent(ScriptContextManager.class);
        when(scriptContextManager.getCurrentScriptContext()).thenReturn(this.scriptContext);
        when(scriptContextManager.getScriptContext()).thenReturn(this.scriptContext);
    }
    // Initialize XWikiContext provider
    if (!this.componentManager.hasComponent(XWikiContext.TYPE_PROVIDER)) {
        Provider<XWikiContext> xcontextProvider = this.componentManager.registerMockComponent(XWikiContext.TYPE_PROVIDER);
        when(xcontextProvider.get()).thenReturn(this.context);
    } else {
        Provider<XWikiContext> xcontextProvider = this.componentManager.getInstance(XWikiContext.TYPE_PROVIDER);
        if (MockUtil.isMock(xcontextProvider)) {
            when(xcontextProvider.get()).thenReturn(this.context);
        }
    }
    // Initialize readonly XWikiContext provider
    if (!this.componentManager.hasComponent(XWikiContext.TYPE_PROVIDER, "readonly")) {
        Provider<XWikiContext> xcontextProvider = this.componentManager.registerMockComponent(XWikiContext.TYPE_PROVIDER, "readonly");
        when(xcontextProvider.get()).thenReturn(this.context);
    } else {
        Provider<XWikiContext> xcontextProvider = this.componentManager.getInstance(XWikiContext.TYPE_PROVIDER);
        if (MockUtil.isMock(xcontextProvider)) {
            when(xcontextProvider.get()).thenReturn(this.context);
        }
    }
    // Initialize stub context provider
    if (this.componentManager.hasComponent(XWikiStubContextProvider.class)) {
        XWikiStubContextProvider stubContextProvider = this.componentManager.getInstance(XWikiStubContextProvider.class);
        if (!MockUtil.isMock(stubContextProvider)) {
            stubContextProvider.initialize(this.context);
        }
    }
    // Make sure to have a mocked CoreConfiguration (even if one already exist)
    if (!this.componentManager.hasComponent(CoreConfiguration.class)) {
        CoreConfiguration coreConfigurationMock = this.componentManager.registerMockComponent(CoreConfiguration.class);
        when(coreConfigurationMock.getDefaultDocumentSyntax()).thenReturn(Syntax.XWIKI_2_1);
    } else {
        CoreConfiguration coreConfiguration = this.componentManager.registerMockComponent(CoreConfiguration.class, false);
        if (MockUtil.isMock(coreConfiguration)) {
            when(coreConfiguration.getDefaultDocumentSyntax()).thenReturn(Syntax.XWIKI_2_1);
        }
    }
    // Set a context ComponentManager if none exist
    if (!this.componentManager.hasComponent(ComponentManager.class, "context")) {
        DefaultComponentDescriptor<ComponentManager> componentManagerDescriptor = new DefaultComponentDescriptor<>();
        componentManagerDescriptor.setRoleHint("context");
        componentManagerDescriptor.setRoleType(ComponentManager.class);
        this.componentManager.registerComponent(componentManagerDescriptor, this.componentManager);
    }
    // XWiki
    doAnswer(new Answer<XWikiDocument>() {

        @Override
        public XWikiDocument answer(InvocationOnMock invocation) throws Throwable {
            XWikiDocument doc = invocation.getArgument(0);
            String revision = invocation.getArgument(1);
            if (StringUtils.equals(revision, doc.getVersion())) {
                return doc;
            }
            // TODO: implement version store mocking
            return new XWikiDocument(doc.getDocumentReference());
        }
    }).when(getSpyXWiki()).getDocument(anyXWikiDocument(), any(), anyXWikiContext());
    doAnswer(new Answer<XWikiDocument>() {

        @Override
        public XWikiDocument answer(InvocationOnMock invocation) throws Throwable {
            DocumentReference target = invocation.getArgument(0);
            if (target.getLocale() == null) {
                target = new DocumentReference(target, Locale.ROOT);
            }
            XWikiDocument document = documents.get(target);
            if (document == null) {
                document = new XWikiDocument(target, target.getLocale());
                document.setSyntax(Syntax.PLAIN_1_0);
                document.setOriginalDocument(document.clone());
            }
            return document;
        }
    }).when(getSpyXWiki()).getDocument(any(DocumentReference.class), anyXWikiContext());
    doAnswer(new Answer<XWikiDocument>() {

        @Override
        public XWikiDocument answer(InvocationOnMock invocation) throws Throwable {
            XWikiDocument target = invocation.getArgument(0);
            return getSpyXWiki().getDocument(target.getDocumentReferenceWithLocale(), invocation.getArgument(1));
        }
    }).when(getSpyXWiki()).getDocument(anyXWikiDocument(), any(XWikiContext.class));
    doAnswer(new Answer<Boolean>() {

        @Override
        public Boolean answer(InvocationOnMock invocation) throws Throwable {
            DocumentReference target = (DocumentReference) invocation.getArguments()[0];
            if (target.getLocale() == null) {
                target = new DocumentReference(target, Locale.ROOT);
            }
            return documents.containsKey(target);
        }
    }).when(getSpyXWiki()).exists(any(DocumentReference.class), anyXWikiContext());
    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            XWikiDocument document = invocation.getArgument(0);
            String comment = invocation.getArgument(1);
            boolean minorEdit = invocation.getArgument(2);
            boolean isNew = document.isNew();
            document.setComment(StringUtils.defaultString(comment));
            document.setMinorEdit(minorEdit);
            if (document.isContentDirty() || document.isMetaDataDirty()) {
                document.setDate(new Date());
                if (document.isContentDirty()) {
                    document.setContentUpdateDate(new Date());
                    document.setContentAuthorReference(document.getAuthorReference());
                }
                document.incrementVersion();
                document.setContentDirty(false);
                document.setMetaDataDirty(false);
            }
            document.setNew(false);
            document.setStore(getMockStore());
            XWikiDocument previousDocument = documents.get(document.getDocumentReferenceWithLocale());
            if (previousDocument != null && previousDocument != document) {
                for (XWikiAttachment attachment : document.getAttachmentList()) {
                    if (!attachment.isContentDirty()) {
                        attachment.setAttachment_content(previousDocument.getAttachment(attachment.getFilename()).getAttachment_content());
                    }
                }
            }
            XWikiDocument originalDocument = document.getOriginalDocument();
            if (originalDocument == null) {
                originalDocument = spyXWiki.getDocument(document.getDocumentReferenceWithLocale(), context);
                document.setOriginalDocument(originalDocument);
            }
            XWikiDocument savedDocument = document.clone();
            documents.put(document.getDocumentReferenceWithLocale(), savedDocument);
            if (isNew) {
                if (notifyDocumentCreatedEvent) {
                    getObservationManager().notify(new DocumentCreatedEvent(document.getDocumentReference()), document, getXWikiContext());
                }
            } else {
                if (notifyDocumentUpdatedEvent) {
                    getObservationManager().notify(new DocumentUpdatedEvent(document.getDocumentReference()), document, getXWikiContext());
                }
            }
            // Set the document as it's original document
            savedDocument.setOriginalDocument(savedDocument.clone());
            return null;
        }
    }).when(getSpyXWiki()).saveDocument(anyXWikiDocument(), any(String.class), anyBoolean(), anyXWikiContext());
    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            XWikiDocument document = invocation.getArgument(0);
            documents.remove(document.getDocumentReferenceWithLocale());
            if (notifyDocumentDeletedEvent) {
                getObservationManager().notify(new DocumentDeletedEvent(document.getDocumentReference()), document, getXWikiContext());
            }
            return null;
        }
    }).when(getSpyXWiki()).deleteDocument(anyXWikiDocument(), any(Boolean.class), anyXWikiContext());
    doAnswer(new Answer<BaseClass>() {

        @Override
        public BaseClass answer(InvocationOnMock invocation) throws Throwable {
            return getSpyXWiki().getDocument((DocumentReference) invocation.getArguments()[0], invocation.getArgument(1)).getXClass();
        }
    }).when(getSpyXWiki()).getXClass(any(DocumentReference.class), anyXWikiContext());
    doAnswer(new Answer<String>() {

        @Override
        public String answer(InvocationOnMock invocation) throws Throwable {
            return getXWikiContext().getLanguage();
        }
    }).when(getSpyXWiki()).getLanguagePreference(anyXWikiContext());
    getXWikiContext().setLocale(Locale.ENGLISH);
    // XWikiStoreInterface
    when(getMockStore().getTranslationList(anyXWikiDocument(), anyXWikiContext())).then(new Answer<List<String>>() {

        @Override
        public List<String> answer(InvocationOnMock invocation) throws Throwable {
            XWikiDocument document = invocation.getArgument(0);
            List<String> translations = new ArrayList<String>();
            for (XWikiDocument storedDocument : documents.values()) {
                Locale storedLocale = storedDocument.getLocale();
                if (!storedLocale.equals(Locale.ROOT) && storedDocument.getDocumentReference().equals(document.getDocumentReference())) {
                    translations.add(storedLocale.toString());
                }
            }
            return translations;
        }
    });
    when(getMockStore().loadXWikiDoc(anyXWikiDocument(), anyXWikiContext())).then(new Answer<XWikiDocument>() {

        @Override
        public XWikiDocument answer(InvocationOnMock invocation) throws Throwable {
            // The store is based on the contex for the wiki
            DocumentReference reference = invocation.<XWikiDocument>getArgument(0).getDocumentReference();
            XWikiContext xcontext = invocation.getArgument(1);
            if (!xcontext.getWikiReference().equals(reference.getWikiReference())) {
                reference = reference.setWikiReference(xcontext.getWikiReference());
            }
            return getSpyXWiki().getDocument(reference, xcontext);
        }
    });
    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            // The store is based on the contex for the wiki
            DocumentReference reference = invocation.<XWikiDocument>getArgument(0).getDocumentReferenceWithLocale();
            XWikiContext xcontext = invocation.getArgument(1);
            if (!xcontext.getWikiReference().equals(reference.getWikiReference())) {
                reference = reference.setWikiReference(xcontext.getWikiReference());
            }
            documents.remove(reference);
            return null;
        }
    }).when(getMockStore()).deleteXWikiDoc(anyXWikiDocument(), anyXWikiContext());
    // Users
    doAnswer(new Answer<BaseClass>() {

        @Override
        public BaseClass answer(InvocationOnMock invocation) throws Throwable {
            XWikiContext xcontext = invocation.getArgument(0);
            XWikiDocument userDocument = getSpyXWiki().getDocument(new DocumentReference(USER_CLASS, new WikiReference(xcontext.getWikiId())), xcontext);
            final BaseClass userClass = userDocument.getXClass();
            if (userDocument.isNew()) {
                userClass.addTextField("first_name", "First Name", 30);
                userClass.addTextField("last_name", "Last Name", 30);
                userClass.addEmailField("email", "e-Mail", 30);
                userClass.addPasswordField("password", "Password", 10);
                userClass.addBooleanField("active", "Active", "active");
                userClass.addTextAreaField("comment", "Comment", 40, 5);
                userClass.addTextField("avatar", "Avatar", 30);
                userClass.addTextField("phone", "Phone", 30);
                userClass.addTextAreaField("address", "Address", 40, 3);
                getSpyXWiki().saveDocument(userDocument, xcontext);
            }
            return userClass;
        }
    }).when(getSpyXWiki()).getUserClass(anyXWikiContext());
    doAnswer(new Answer<BaseClass>() {

        @Override
        public BaseClass answer(InvocationOnMock invocation) throws Throwable {
            XWikiContext xcontext = invocation.getArgument(0);
            XWikiDocument groupDocument = getSpyXWiki().getDocument(new DocumentReference(GROUP_CLASS, new WikiReference(xcontext.getWikiId())), xcontext);
            final BaseClass groupClass = groupDocument.getXClass();
            if (groupDocument.isNew()) {
                groupClass.addTextField("member", "Member", 30);
                getSpyXWiki().saveDocument(groupDocument, xcontext);
            }
            return groupClass;
        }
    }).when(getSpyXWiki()).getGroupClass(anyXWikiContext());
    // This allows, for example, using @ComponentList to use the real Query Manager, in integration tests.
    if (!this.componentManager.hasComponent(QueryManager.class)) {
        mockQueryManager();
    }
    when(getMockStore().getQueryManager()).then(new Answer<QueryManager>() {

        @Override
        public QueryManager answer(InvocationOnMock invocation) throws Throwable {
            return getQueryManager();
        }
    });
    // This allows, for example, using @ComponentList to use the real WikiDescriptorManager, in integration tests.
    if (!this.componentManager.hasComponent(WikiDescriptorManager.class)) {
        this.wikiDescriptorManager = getMocker().registerMockComponent(WikiDescriptorManager.class);
        when(this.wikiDescriptorManager.getMainWikiId()).then(new Answer<String>() {

            @Override
            public String answer(InvocationOnMock invocation) throws Throwable {
                return getXWikiContext().getMainXWiki();
            }
        });
        when(this.wikiDescriptorManager.getCurrentWikiId()).then(new Answer<String>() {

            @Override
            public String answer(InvocationOnMock invocation) throws Throwable {
                return getXWikiContext().getWikiId();
            }
        });
    }
}
Also used : XWikiStubContextProvider(com.xpn.xwiki.util.XWikiStubContextProvider) Locale(java.util.Locale) ExecutionContextManager(org.xwiki.context.ExecutionContextManager) DocumentUpdatedEvent(org.xwiki.bridge.event.DocumentUpdatedEvent) XWikiAttachment(com.xpn.xwiki.doc.XWikiAttachment) XWikiVersioningStoreInterface(com.xpn.xwiki.store.XWikiVersioningStoreInterface) Execution(org.xwiki.context.Execution) DefaultComponentDescriptor(org.xwiki.component.descriptor.DefaultComponentDescriptor) BaseClass(com.xpn.xwiki.objects.classes.BaseClass) List(java.util.List) ArrayList(java.util.ArrayList) ArgumentMatchers.anyBoolean(org.mockito.ArgumentMatchers.anyBoolean) LocalDocumentReference(org.xwiki.model.reference.LocalDocumentReference) DocumentReference(org.xwiki.model.reference.DocumentReference) MemoryConfigurationSource(org.xwiki.configuration.internal.MemoryConfigurationSource) XWikiCfgConfigurationSource(com.xpn.xwiki.internal.XWikiCfgConfigurationSource) MockConfigurationSource(org.xwiki.test.internal.MockConfigurationSource) ConfigurationSource(org.xwiki.configuration.ConfigurationSource) WikiDescriptorManager(org.xwiki.wiki.descriptor.WikiDescriptorManager) OldcoreMatchers.anyXWikiContext(com.xpn.xwiki.test.mockito.OldcoreMatchers.anyXWikiContext) XWikiContext(com.xpn.xwiki.XWikiContext) XWiki(com.xpn.xwiki.XWiki) AllComponents(org.xwiki.test.annotation.AllComponents) ExecutionContext(org.xwiki.context.ExecutionContext) XWikiRightService(com.xpn.xwiki.user.api.XWikiRightService) ServletEnvironment(org.xwiki.environment.internal.ServletEnvironment) Environment(org.xwiki.environment.Environment) WikiReference(org.xwiki.model.reference.WikiReference) File(java.io.File) ContextualAuthorizationManager(org.xwiki.security.authorization.ContextualAuthorizationManager) MockConfigurationSource(org.xwiki.test.internal.MockConfigurationSource) CoreConfiguration(com.xpn.xwiki.CoreConfiguration) OldcoreMatchers.anyXWikiDocument(com.xpn.xwiki.test.mockito.OldcoreMatchers.anyXWikiDocument) XWikiDocument(com.xpn.xwiki.doc.XWikiDocument) ComponentManager(org.xwiki.component.manager.ComponentManager) MockitoComponentManager(org.xwiki.test.mockito.MockitoComponentManager) ServletContext(javax.servlet.ServletContext) ServletEnvironment(org.xwiki.environment.internal.ServletEnvironment) XWikiGroupService(com.xpn.xwiki.user.api.XWikiGroupService) SimpleScriptContext(javax.script.SimpleScriptContext) DocumentCreatedEvent(org.xwiki.bridge.event.DocumentCreatedEvent) ScriptContextManager(org.xwiki.script.ScriptContextManager) Date(java.util.Date) DocumentDeletedEvent(org.xwiki.bridge.event.DocumentDeletedEvent) XWikiHibernateStore(com.xpn.xwiki.store.XWikiHibernateStore) InvocationOnMock(org.mockito.invocation.InvocationOnMock) QueryManager(org.xwiki.query.QueryManager) AuthorizationManager(org.xwiki.security.authorization.AuthorizationManager) ContextualAuthorizationManager(org.xwiki.security.authorization.ContextualAuthorizationManager)

Example 9 with QueryManager

use of org.xwiki.query.QueryManager in project xwiki-platform by xwiki.

the class XWikiHibernateStoreTest method getTranslationList.

@Test
public void getTranslationList() throws Exception {
    DocumentReference documentReference = new DocumentReference("chess", Arrays.asList("Path", "To"), "Success");
    XWikiDocument doc = mock(XWikiDocument.class);
    when(doc.getDocumentReference()).thenReturn(documentReference);
    org.xwiki.query.Query query = mock(org.xwiki.query.Query.class);
    List<Object> translationList = Arrays.<Object>asList("fr", "ro");
    when(query.execute()).thenReturn(translationList);
    QueryManager queryManager = this.mocker.getInstance(QueryManager.class);
    when(queryManager.createQuery(any(String.class), eq(org.xwiki.query.Query.HQL))).thenReturn(query);
    EntityReferenceSerializer<String> localEntityReferenceSerialzier = this.mocker.getInstance(EntityReferenceSerializer.TYPE_STRING, "local");
    when(localEntityReferenceSerialzier.serialize(documentReference.getParent())).thenReturn("Path.To");
    assertEquals(translationList, store.getTranslationList(doc, xcontext));
    verify(query).setWiki(documentReference.getWikiReference().getName());
    verify(query).bindValue("space", "Path.To");
    verify(query).bindValue("name", documentReference.getName());
}
Also used : XWikiDocument(com.xpn.xwiki.doc.XWikiDocument) QueryManager(org.xwiki.query.QueryManager) BaseObject(com.xpn.xwiki.objects.BaseObject) DocumentReference(org.xwiki.model.reference.DocumentReference) Test(org.junit.Test)

Example 10 with QueryManager

use of org.xwiki.query.QueryManager in project xwiki-platform by xwiki.

the class DefaultWikiMacroInitializer method getWikiMacroDocumentData.

/**
 * Search for all wiki macros in the current wiki.
 *
 * @param xcontext the current request context
 * @return a list of documents containing wiki macros, each item as a List of 3 strings: space name, document name,
 *         last author of the document
 * @throws Exception if the database search fails
 */
private List<Object[]> getWikiMacroDocumentData(XWikiContext xcontext) throws Exception {
    final QueryManager qm = xcontext.getWiki().getStore().getQueryManager();
    final Query q = qm.getNamedQuery("getWikiMacroDocuments");
    return (List<Object[]>) (List) q.execute();
}
Also used : Query(org.xwiki.query.Query) QueryManager(org.xwiki.query.QueryManager) List(java.util.List)

Aggregations

QueryManager (org.xwiki.query.QueryManager)22 Query (org.xwiki.query.Query)18 DocumentReference (org.xwiki.model.reference.DocumentReference)11 Before (org.junit.Before)7 Test (org.junit.Test)7 XWikiContext (com.xpn.xwiki.XWikiContext)6 XWiki (com.xpn.xwiki.XWiki)5 ArrayList (java.util.ArrayList)5 List (java.util.List)5 XWikiException (com.xpn.xwiki.XWikiException)4 XWikiDocument (com.xpn.xwiki.doc.XWikiDocument)4 Map (java.util.Map)4 BaseObject (com.xpn.xwiki.objects.BaseObject)3 Date (java.util.Date)3 HashMap (java.util.HashMap)3 QueryException (org.xwiki.query.QueryException)3 ImmutablePair (org.apache.commons.lang3.tuple.ImmutablePair)2 Pair (org.apache.commons.lang3.tuple.Pair)2 Expectations (org.jmock.Expectations)2 ConfigurationSource (org.xwiki.configuration.ConfigurationSource)2