This is an automated email from the ASF dual-hosted git repository.

snoopdave pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/roller.git

commit 556593883adce5272eaea87342ef4ec3c1d09752
Merge: 0308b4314 69d0d5eef
Author: David M. Johnson <[email protected]>
AuthorDate: Sat Oct 31 19:31:27 2026 -0400

    Merge branch 'roller-6.1.x' into master
    
    OpenID sign-in code from 6.1.x is left out: master replaced OpenID with
    OIDC. Servlet imports use jakarta, and PingTargetEdit uses Struts 7's
    withServletRequest.

 CHANGES.md                                         |  50 ++++++
 .../roller/weblogger/business/UserManager.java     |  17 +-
 .../business/jpa/JPABookmarkManagerImpl.java       |  33 ++++
 .../weblogger/business/jpa/JPAUserManagerImpl.java |  35 +++-
 .../weblogger/business/search/IndexManager.java    |  13 ++
 .../business/search/lucene/FieldConstants.java     |   3 +
 .../business/search/lucene/IndexOperation.java     |  28 ---
 .../business/search/lucene/LuceneIndexManager.java | 111 ++++++++----
 .../business/search/lucene/SearchOperation.java    |  49 ++++-
 .../business/themes/WeblogCustomTheme.java         |   8 +
 .../pojos/wrapper/WeblogBookmarkWrapper.java       |  27 ++-
 .../rendering/servlets/PreviewResourceServlet.java |  15 ++
 .../ui/rendering/servlets/PreviewServlet.java      |   8 +-
 .../ui/rendering/servlets/ResourceServlet.java     |   8 +
 .../weblogger/ui/rendering/util/PreviewAccess.java |  50 ++++++
 .../weblogger/ui/struts2/admin/PingTargetEdit.java |  14 ++
 .../weblogger/ui/struts2/admin/PingTargets.java    |   4 +-
 .../weblogger/ui/struts2/ajax/UserDataServlet.java |  13 +-
 .../roller/weblogger/ui/struts2/core/MainMenu.java |   4 +-
 .../weblogger/ui/struts2/editor/EntryEdit.java     |   6 +-
 .../weblogger/ui/struts2/editor/EntryRemove.java   |  15 +-
 .../weblogger/ui/struts2/editor/MediaFileBean.java |   6 +-
 .../weblogger/ui/struts2/editor/MediaFileEdit.java |   3 +
 .../roller/weblogger/ui/struts2/editor/Pings.java  |   6 +-
 .../roller/weblogger/ui/struts2/util/UIAction.java |   3 +
 .../ui/struts2/util/ValidateSaltInterceptor.java   |  30 +++-
 .../apache/roller/weblogger/util/LinkScheme.java   |  73 ++++++++
 .../roller/weblogger/util/MediaTypePolicy.java     |  26 +++
 .../apache/roller/weblogger/util/Utilities.java    |  59 +++++-
 .../webservices/atomprotocol/EntryCollection.java  |  18 +-
 .../org/apache/roller/weblogger/pojos/User.orm.xml |  10 +-
 app/src/main/resources/struts.xml                  |  21 +++
 .../main/webapp/WEB-INF/jsps/admin/PingTargets.jsp |  20 +--
 .../webapp/WEB-INF/jsps/core/CreateDatabase.jsp    |  14 +-
 app/src/main/webapp/WEB-INF/jsps/core/MainMenu.jsp |  26 +--
 .../webapp/WEB-INF/jsps/core/UpgradeDatabase.jsp   |  14 +-
 app/src/main/webapp/WEB-INF/jsps/editor/Pings.jsp  |  32 ++--
 app/src/main/webapp/WEB-INF/velocity/weblog.vm     |  22 +--
 .../business/BookmarkImportParsingTest.java        |  32 ++++
 .../apache/roller/weblogger/business/UserTest.java |  15 ++
 .../business/jpa/JPAUserManagerLikePrefixTest.java |  37 ++++
 .../business/search/IndexManagerTest.java          |  34 ++++
 .../business/search/UpdateEntryIndexTest.java      |  63 +++++++
 .../business/search/lucene/IndexedFieldsTest.java  | 108 +++++++++++
 .../search/lucene/SearchFieldsQueryParserTest.java |  69 +++++++
 .../search/lucene/SearchHitPagingTest.java         | 112 ++++++++++++
 .../business/themes/WeblogCustomThemeTest.java     |   9 +
 .../pojos/wrapper/WeblogBookmarkWrapperTest.java   |  56 ++++++
 .../servlets/PreviewResourceServletTest.java       | 200 +++++++++++++++++++++
 .../servlets/PreviewServletAccessTest.java         |  64 +++++++
 .../ui/rendering/servlets/ResourceServletTest.java | 158 ++++++++++++++++
 .../ui/rendering/util/PreviewAccessTest.java       | 109 +++++++++++
 .../ui/struts2/admin/PingTargetEditTest.java       |  94 ++++++++++
 .../ui/struts2/ajax/UserDataServletTest.java       | 132 ++++++++++++++
 .../ui/struts2/editor/MediaFileBeanTest.java       |  47 +++++
 .../ui/struts2/editor/MediaFileEditTest.java       | 113 ++++++++++++
 .../struts2/util/ValidateSaltInterceptorTest.java  |  60 +++++++
 .../roller/weblogger/util/LinkSchemeTest.java      |  51 ++++++
 .../roller/weblogger/util/MediaTypePolicyTest.java |  48 ++++-
 .../roller/weblogger/util/UtilitiesTest.java       |  37 ++++
 60 files changed, 2360 insertions(+), 182 deletions(-)

diff --cc 
app/src/main/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEdit.java
index 93c956eee,6689b8c64..f267bcf28
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEdit.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEdit.java
@@@ -18,6 -18,8 +18,8 @@@
  
  package org.apache.roller.weblogger.ui.struts2.admin;
  
 -import javax.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletRequest;
+ 
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
@@@ -149,4 -156,9 +157,10 @@@ public class PingTargetEdit extends UIA
      public void setBean(PingTargetBean bean) {
          this.bean = bean;
      }
+ 
+     @Override
 -    public void setServletRequest(HttpServletRequest req) {
++    public void withServletRequest(HttpServletRequest req) {
++        super.withServletRequest(req);
+         httpMethod = req.getMethod();
+     }
  }
diff --cc 
app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/MediaFileEdit.java
index fe9d46a83,789ba2a6d..23116c007
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/MediaFileEdit.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/editor/MediaFileEdit.java
@@@ -1,144 -1,141 +1,147 @@@
 -/*
 - * Licensed to the Apache Software Foundation (ASF) under one or more
 - *  contributor license agreements.  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.  For additional information regarding
 - * copyright in this work, please see the NOTICE file in the top level
 - * directory of this distribution.
 - */
 -package org.apache.roller.weblogger.ui.struts2.editor;
 -
 -import java.io.File;
 -import java.io.FileInputStream;
 -
 -import org.apache.commons.lang3.StringUtils;
 -import org.apache.commons.logging.Log;
 -import org.apache.commons.logging.LogFactory;
 -import org.apache.roller.weblogger.util.MediaTypePolicy;
 -import org.apache.roller.weblogger.WebloggerException;
 -import org.apache.roller.weblogger.business.FileIOException;
 -import org.apache.roller.weblogger.business.MediaFileManager;
 -import org.apache.roller.weblogger.business.WebloggerFactory;
 -import org.apache.roller.weblogger.pojos.MediaFile;
 -import org.apache.roller.weblogger.pojos.MediaFileDirectory;
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + *  contributor license agreements.  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.  For additional information regarding
 + * copyright in this work, please see the NOTICE file in the top level
 + * directory of this distribution.
 + */
 +package org.apache.roller.weblogger.ui.struts2.editor;
 +
 +import java.io.File;
 +import java.io.FileInputStream;
 +
 +import org.apache.commons.lang3.StringUtils;
 +import org.apache.commons.logging.Log;
 +import org.apache.commons.logging.LogFactory;
 +import org.apache.roller.weblogger.util.MediaTypePolicy;
 +import org.apache.roller.weblogger.WebloggerException;
 +import org.apache.roller.weblogger.business.FileIOException;
 +import org.apache.roller.weblogger.business.MediaFileManager;
 +import org.apache.roller.weblogger.business.WebloggerFactory;
 +import org.apache.roller.weblogger.pojos.MediaFile;
 +import org.apache.roller.weblogger.pojos.MediaFileDirectory;
 +import org.apache.struts2.action.UploadedFilesAware;
  import org.apache.roller.weblogger.ui.core.RollerContext;
  import org.apache.roller.weblogger.util.RollerMessages;
 -import org.apache.struts2.convention.annotation.AllowedMethods;
 -import org.apache.struts2.interceptor.validation.SkipValidation;
 -
 -/**
 - * Edits metadata for a media file.
 - */
 -@SuppressWarnings("serial")
 -// TODO: make this work @AllowedMethods({"execute","save"})
 -public class MediaFileEdit extends MediaFileBase {
 -
 -    private static Log log = LogFactory.getLog(MediaFileEdit.class);
 -    private MediaFileBean bean = new MediaFileBean();
 -    private MediaFileDirectory directory;
 -
 -    // file uploaded by the user, if applicable
 -    private File uploadedFile = null;
 -
 -    // content types for upload file
 -    private String uploadedFileContentType = null;
 -
 -    // filename for uploaded file
 -    private String uploadedFileName = null;
 -
 -    public MediaFileEdit() {
 -        this.actionName = "mediaFileEdit";
 -        this.desiredMenu = "editor";
 -        this.pageTitle = "mediaFile.edit.title";
 -    }
 -
 -    /**
 -     * Prepares edit action.
 -     */
 -    @Override
 -    public void myPrepare() {
 -        refreshAllDirectories();
 -        try {
 -            MediaFileManager mgr = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 -            if (!StringUtils.isEmpty(bean.getDirectoryId())) {
 -                setDirectory(mgr.getMediaFileDirectory(getActionWeblog(), 
bean.getDirectoryId()));
 -            }
 -        } catch (WebloggerException ex) {
 -            log.error("Error looking up media file directory", ex);
 -        }
 -
 -    }
 -
 -    /**
 -     * Validates media file metadata to be updated.
 -     */
 -    public void myValidate() {
 -        MediaFile fileWithSameName = 
getDirectory().getMediaFile(getBean().getName());
 -        if (fileWithSameName != null && 
!fileWithSameName.getId().equals(getMediaFileId())) {
 -            addError("MediaFile.error.duplicateName", getBean().getName());
 -        }
 -    }
 -
 -    /**
 -     * Show form for adding a new media file.
 -     * 
 -     * @return String The result of the action.
 -     */
 -    @SkipValidation
 -    @Override
 -    public String execute() {
 -        MediaFileManager manager = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 -        try {
 -            MediaFile mediaFile = manager.getMediaFile(getActionWeblog(), 
getMediaFileId());
 -            this.bean.copyFrom(mediaFile);
 -
 -        } catch (FileIOException ex) {
 -            addError("uploadFiles.error.upload", bean.getName());
 -
 -        } catch (Exception e) {
 -            log.error("Error uploading file " + bean.getName(), e);
 -            addError("uploadFiles.error.upload", bean.getName());
 -        }
 -
 -        return INPUT;
 -    }
 -
 -    /**
 -     * Save a media file.
 -     * 
 -     * @return String The result of the action.
 -     */
 -    public String save() {
 -        myValidate();
 -        if (!hasActionErrors()) {
 -            MediaFileManager manager = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 -            try {
 -                MediaFile mediaFile = manager.getMediaFile(getActionWeblog(), 
getMediaFileId());
 -                bean.copyTo(mediaFile);
 -                if (getBooleanProp("mediafile.originalPathEdit.enabled")) {
 -                    mediaFile.setOriginalPath(bean.getOriginalPath());
 -                }
 -
 -                if (uploadedFile != null) {
 -                    mediaFile.setLength(this.uploadedFile.length());
 +import org.apache.struts2.convention.annotation.AllowedMethods;
 +import org.apache.struts2.dispatcher.multipart.UploadedFile;
 +import org.apache.struts2.interceptor.parameter.StrutsParameter;
 +import org.apache.struts2.interceptor.validation.SkipValidation;
 +
 +import java.util.List;
 +
 +/**
 + * Edits metadata for a media file.
 + */
 +@SuppressWarnings("serial")
 +// TODO: make this work @AllowedMethods({"execute","save"})
 +public class MediaFileEdit extends MediaFileBase implements 
UploadedFilesAware {
 +
 +    private static Log log = LogFactory.getLog(MediaFileEdit.class);
 +    private MediaFileBean bean = new MediaFileBean();
 +    private MediaFileDirectory directory;
 +
 +    // replacement file uploaded by the user, if applicable, injected
 +    // by the actionFileUpload interceptor
 +    private UploadedFile uploadedFile = null;
 +
 +    public MediaFileEdit() {
 +        this.actionName = "mediaFileEdit";
 +        this.desiredMenu = "editor";
 +        this.pageTitle = "mediaFile.edit.title";
 +    }
 +
 +    /**
 +     * Prepares edit action.
 +     */
 +    @Override
 +    public void myPrepare() {
 +        refreshAllDirectories();
 +        try {
 +            MediaFileManager mgr = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 +            if (!StringUtils.isEmpty(bean.getDirectoryId())) {
 +                setDirectory(mgr.getMediaFileDirectory(getActionWeblog(), 
bean.getDirectoryId()));
 +            }
 +        } catch (WebloggerException ex) {
 +            log.error("Error looking up media file directory", ex);
 +        }
 +
 +    }
 +
 +    @Override
 +    public void withUploadedFiles(List<UploadedFile> uploadedFiles) {
 +        this.uploadedFile = uploadedFiles.isEmpty() ? null : 
uploadedFiles.get(0);
 +    }
 +
 +    /**
 +     * Validates media file metadata to be updated.
 +     */
 +    public void myValidate() {
 +        MediaFile fileWithSameName = 
getDirectory().getMediaFile(getBean().getName());
 +        if (fileWithSameName != null && 
!fileWithSameName.getId().equals(getMediaFileId())) {
 +            addError("MediaFile.error.duplicateName", getBean().getName());
 +        }
 +    }
 +
 +    /**
 +     * Show form for adding a new media file.
 +     * 
 +     * @return String The result of the action.
 +     */
 +    @SkipValidation
 +    @Override
 +    public String execute() {
 +        MediaFileManager manager = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 +        try {
 +            MediaFile mediaFile = manager.getMediaFile(getActionWeblog(), 
getMediaFileId());
 +            this.bean.copyFrom(mediaFile);
 +
 +        } catch (FileIOException ex) {
 +            addError("uploadFiles.error.upload", bean.getName());
 +
 +        } catch (Exception e) {
 +            log.error("Error uploading file " + bean.getName(), e);
 +            addError("uploadFiles.error.upload", bean.getName());
 +        }
 +
 +        return INPUT;
 +    }
 +
 +    /**
 +     * Save a media file.
 +     * 
 +     * @return String The result of the action.
 +     */
 +    public String save() {
 +        myValidate();
 +        if (!hasActionErrors()) {
 +            MediaFileManager manager = 
WebloggerFactory.getWeblogger().getMediaFileManager();
 +            try {
 +                MediaFile mediaFile = manager.getMediaFile(getActionWeblog(), 
getMediaFileId());
 +                bean.copyTo(mediaFile);
++                if (getBooleanProp("mediafile.originalPathEdit.enabled")) {
++                    mediaFile.setOriginalPath(bean.getOriginalPath());
++                }
 +
 +                if (uploadedFile != null
 +                        && uploadedFile.getContent() instanceof File 
uploadFile) {
 +                    mediaFile.setLength(uploadFile.length());
                      String declaredType = MediaTypePolicy.normalizeType(
 -                            this.uploadedFileContentType);
 +                            uploadedFile.getContentType());
                      RollerMessages errors = new RollerMessages();
                      if 
(!WebloggerFactory.getWeblogger().getFileContentManager().canSave(
 -                            getActionWeblog(), this.uploadedFileName, 
declaredType,
 -                            this.uploadedFile.length(), errors)) {
 +                            getActionWeblog(), 
uploadedFile.getOriginalName(), declaredType,
 +                            uploadFile.length(), errors)) {
                          throw new FileIOException(errors.toString());
                      }
                      // Replacing the body re-decides the type, on the same
diff --cc 
app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
index 466dbc5ed,49ae86b9d..2fe9914fa
--- 
a/app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptor.java
@@@ -19,8 -19,11 +19,11 @@@
  
  package org.apache.roller.weblogger.ui.struts2.util;
  
+ import java.util.Set;
+ 
 -import javax.servlet.ServletException;
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
 +import jakarta.servlet.ServletException;
 +import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
@@@ -28,12 -31,14 +31,14 @@@ import org.apache.roller.weblogger.ui.c
  import org.apache.struts2.StrutsStatics;
  import org.apache.struts2.dispatcher.multipart.MultiPartRequestWrapper;
  
 -import com.opensymphony.xwork2.Action;
 -import com.opensymphony.xwork2.ActionContext;
 -import com.opensymphony.xwork2.ActionInvocation;
 -import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
 +import org.apache.struts2.ActionContext;
 +import org.apache.struts2.ActionInvocation;
++import org.apache.struts2.action.Action;
 +import org.apache.struts2.interceptor.AbstractInterceptor;
  
  /**
-  * Validates salts after Struts has wrapped a multipart form request.
+  * Validates salts after Struts has wrapped a multipart form request, and
+  * refuses requests other than POST to action methods that change data.
   */
  public class ValidateSaltInterceptor extends AbstractInterceptor implements 
StrutsStatics {
  
diff --cc 
app/src/main/java/org/apache/roller/weblogger/webservices/atomprotocol/EntryCollection.java
index d65daaa82,a7d12bd44..97280803a
--- 
a/app/src/main/java/org/apache/roller/weblogger/webservices/atomprotocol/EntryCollection.java
+++ 
b/app/src/main/java/org/apache/roller/weblogger/webservices/atomprotocol/EntryCollection.java
@@@ -243,11 -262,9 +242,9 @@@ public class EntryCollection 
                      rollerEntry.setUpdateTime(new Timestamp(new 
Date().getTime()));
                      mgr.saveWeblogEntry(rollerEntry);
                      roller.flush();
 -                    
 +
                      CacheManager.invalidate(rollerEntry.getWebsite());
-                     if (rollerEntry.isPublished()) {
-                         
roller.getIndexManager().addEntryReIndexOperation(rollerEntry);
-                     }
+                     roller.getIndexManager().updateEntryIndex(rollerEntry);
                      log.debug("Exiting");
                      return;
                  }
@@@ -425,18 -454,7 +422,7 @@@
              }
              tags = buff.toString();
          }
 -        rollerEntry.setTagsAsString(tags);        
 +        rollerEntry.setTagsAsString(tags);
      }
  
-     private void reindexEntry(WeblogEntry entry) throws WebloggerException {
-         IndexManager manager = roller.getIndexManager();
- 
-         // TODO: figure out what's up here and at WeblogEntryFormAction line 
696
-         //manager.removeEntryIndexOperation(entry);
- 
-         // if published, index the entry
-         if (entry.isPublished()) {
-             manager.addEntryReIndexOperation(entry);
-         }
-     }
 -}
 +}
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewResourceServletTest.java
index 000000000,1315ef3a3..aa5a855e0
mode 000000,100644..100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewResourceServletTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewResourceServletTest.java
@@@ -1,0 -1,200 +1,200 @@@
+ /*
+  * 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
+  *
+  *     https://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.roller.weblogger.ui.rendering.servlets;
+ 
+ import java.io.ByteArrayInputStream;
+ import java.io.ByteArrayOutputStream;
+ import java.nio.charset.StandardCharsets;
+ 
 -import javax.servlet.ServletConfig;
 -import javax.servlet.ServletContext;
 -import javax.servlet.ServletOutputStream;
 -import javax.servlet.WriteListener;
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
++import jakarta.servlet.ServletConfig;
++import jakarta.servlet.ServletContext;
++import jakarta.servlet.ServletOutputStream;
++import jakarta.servlet.WriteListener;
++import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
+ 
+ import org.apache.roller.weblogger.business.MediaFileManager;
+ import org.apache.roller.weblogger.business.Weblogger;
+ import org.apache.roller.weblogger.business.WebloggerFactory;
+ import org.apache.roller.weblogger.business.themes.WeblogCustomTheme;
+ import org.apache.roller.weblogger.pojos.MediaFile;
+ import org.apache.roller.weblogger.pojos.User;
+ import org.apache.roller.weblogger.pojos.Weblog;
+ import org.apache.roller.weblogger.pojos.WeblogPermission;
+ import 
org.apache.roller.weblogger.ui.rendering.util.WeblogPreviewResourceRequest;
+ import org.junit.jupiter.api.AfterEach;
+ import org.junit.jupiter.api.BeforeEach;
+ import org.junit.jupiter.api.Test;
+ import org.mockito.MockedConstruction;
+ import org.mockito.MockedStatic;
+ 
+ import static org.junit.jupiter.api.Assertions.assertEquals;
+ import static org.mockito.ArgumentMatchers.anyString;
+ import static org.mockito.ArgumentMatchers.eq;
+ import static org.mockito.Mockito.mock;
+ import static org.mockito.Mockito.mockConstruction;
+ import static org.mockito.Mockito.mockStatic;
+ import static org.mockito.Mockito.never;
+ import static org.mockito.Mockito.verify;
+ import static org.mockito.Mockito.when;
+ 
+ /**
+  * Preview finds a resource either in the theme being previewed or in the
+  * weblog's own theme. With a custom theme, both reach the media library.
+  * Only an enabled user with a role in the weblog gets a preview.
+  */
+ class PreviewResourceServletTest {
+ 
+     private MockedStatic<WebloggerFactory> factory;
+     private MediaFileManager media;
+     private User user;
+     private Weblog weblog;
+     private PreviewResourceServlet servlet;
+ 
+     @BeforeEach
+     void setUp() throws Exception {
+         media = mock(MediaFileManager.class);
+         Weblogger roller = mock(Weblogger.class);
+         when(roller.getMediaFileManager()).thenReturn(media);
+         user = mock(User.class);
+         when(user.getEnabled()).thenReturn(Boolean.TRUE);
+         factory = mockStatic(WebloggerFactory.class);
+         factory.when(WebloggerFactory::getWeblogger).thenReturn(roller);
+ 
+         weblog = mock(Weblog.class);
+         when(weblog.getTheme()).thenReturn(new WeblogCustomTheme(weblog));
+         when(weblog.hasUserPermission(user, 
WeblogPermission.EDIT_DRAFT)).thenReturn(true);
+ 
+         ServletContext context = mock(ServletContext.class);
+         when(context.getMimeType("page.html")).thenReturn("text/html");
+         when(context.getMimeType("/page.html")).thenReturn("text/html");
+         when(context.getMimeType("/css/site.css")).thenReturn("text/css");
+         ServletConfig config = mock(ServletConfig.class);
+         when(config.getServletContext()).thenReturn(context);
+ 
+         servlet = new PreviewResourceServlet();
+         servlet.init(config);
+     }
+ 
+     @AfterEach
+     void tearDown() {
+         factory.close();
+     }
+ 
+     @Test
+     void uploadedDocumentFoundByPreviewedThemeIsADownload() throws Exception {
+         HttpServletResponse response = serve("custom", "/page.html", 
"<p>page</p>");
+ 
+         verify(response).setContentType("application/octet-stream");
+         verify(response).setHeader("Content-Disposition",
+                 "attachment; filename=\"/page.html\"");
+         verify(response).setHeader("X-Content-Type-Options", "nosniff");
+         verify(response, never()).setContentType("text/html");
+     }
+ 
+     @Test
+     void uploadedDocumentFoundByWeblogThemeIsADownload() throws Exception {
+         HttpServletResponse response = serve(null, "/page.html", 
"<p>page</p>");
+ 
+         verify(response).setContentType("application/octet-stream");
+         verify(response, never()).setContentType("text/html");
+     }
+ 
+     @Test
+     void customThemeStylesheetKeepsItsType() throws Exception {
+         HttpServletResponse response = serve(null, "/css/site.css", "body 
{}");
+ 
+         verify(response).setContentType("text/css");
+         verify(response).setHeader("X-Content-Type-Options", "nosniff");
+         verify(response, never()).setHeader(eq("Content-Disposition"), 
anyString());
+     }
+ 
+     @Test
+     void userWithoutWeblogRoleGetsNotFound() throws Exception {
+         when(weblog.hasUserPermission(user, 
WeblogPermission.EDIT_DRAFT)).thenReturn(false);
+         HttpServletResponse response = serve(null, "/css/site.css", "body 
{}", "");
+ 
+         verify(response).sendError(HttpServletResponse.SC_NOT_FOUND);
+         verify(response, never()).setContentType(anyString());
+     }
+ 
+     @Test
+     void disabledUserGetsNotFound() throws Exception {
+         when(user.getEnabled()).thenReturn(Boolean.FALSE);
+         HttpServletResponse response = serve(null, "/css/site.css", "body 
{}", "");
+ 
+         verify(response).sendError(HttpServletResponse.SC_NOT_FOUND);
+     }
+ 
+     private HttpServletResponse serve(String themeName, String path, String 
body)
+             throws Exception {
+         return serve(themeName, path, body, body);
+     }
+ 
+     private HttpServletResponse serve(String themeName, String path, String 
body, String expected)
+             throws Exception {
+         MediaFile file = mock(MediaFile.class);
+         when(file.getOriginalPath()).thenReturn(path);
+         when(file.getInputStream()).thenReturn(
+                 new 
ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8)));
+         when(media.getMediaFileByOriginalPath(weblog, path)).thenReturn(file);
+ 
+         HttpServletRequest request = mock(HttpServletRequest.class);
+         when(request.getDateHeader("If-Modified-Since")).thenReturn(-1L);
+         HttpServletResponse response = mock(HttpServletResponse.class);
+         ByteArrayOutputStream written = new ByteArrayOutputStream();
+         when(response.getOutputStream()).thenReturn(new 
CapturingStream(written));
+ 
+         try (MockedConstruction<WeblogPreviewResourceRequest> parsed = 
mockConstruction(
+                 WeblogPreviewResourceRequest.class, (mocked, ctx) -> {
+                     when(mocked.getWeblog()).thenReturn(weblog);
+                     when(mocked.getUser()).thenReturn(user);
+                     when(mocked.getResourcePath()).thenReturn(path);
+                     when(mocked.getThemeName()).thenReturn(themeName);
+                     if (themeName != null) {
+                         when(mocked.getTheme()).thenReturn(new 
WeblogCustomTheme(weblog));
+                     }
+                 })) {
+             servlet.doGet(request, response);
+         }
+ 
+         assertEquals(expected, 
written.toString(StandardCharsets.UTF_8.name()));
+         return response;
+     }
+ 
+     private static final class CapturingStream extends ServletOutputStream {
+         private final ByteArrayOutputStream target;
+ 
+         CapturingStream(ByteArrayOutputStream target) {
+             this.target = target;
+         }
+ 
+         @Override
+         public void write(int b) {
+             target.write(b);
+         }
+ 
+         @Override
+         public boolean isReady() {
+             return true;
+         }
+ 
+         @Override
+         public void setWriteListener(WriteListener listener) {
+         }
+     }
+ }
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewServletAccessTest.java
index 000000000,ea9894767..4452c06c3
mode 000000,100644..100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewServletAccessTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/PreviewServletAccessTest.java
@@@ -1,0 -1,64 +1,64 @@@
+ /*
+  * 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
+  *
+  *     https://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.roller.weblogger.ui.rendering.servlets;
+ 
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
++import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
+ 
+ import org.apache.roller.weblogger.pojos.User;
+ import org.apache.roller.weblogger.pojos.Weblog;
+ import org.apache.roller.weblogger.pojos.WeblogPermission;
+ import org.apache.roller.weblogger.ui.rendering.util.WeblogPreviewRequest;
+ import org.junit.jupiter.api.Test;
+ import org.mockito.MockedConstruction;
+ 
+ import static org.mockito.ArgumentMatchers.anyString;
+ import static org.mockito.Mockito.mock;
+ import static org.mockito.Mockito.mockConstruction;
+ import static org.mockito.Mockito.never;
+ import static org.mockito.Mockito.verify;
+ import static org.mockito.Mockito.when;
+ 
+ /**
+  * The page preview servlet refuses users without a role in the weblog.
+  */
+ class PreviewServletAccessTest {
+ 
+     @Test
+     void userWithoutWeblogRoleGetsNotFound() throws Exception {
+         User user = mock(User.class);
+         when(user.getEnabled()).thenReturn(Boolean.TRUE);
+         Weblog weblog = mock(Weblog.class);
+         when(weblog.hasUserPermission(user, 
WeblogPermission.EDIT_DRAFT)).thenReturn(false);
+ 
+         HttpServletRequest request = mock(HttpServletRequest.class);
+         HttpServletResponse response = mock(HttpServletResponse.class);
+ 
+         try (MockedConstruction<WeblogPreviewRequest> parsed = 
mockConstruction(
+                 WeblogPreviewRequest.class, (mocked, ctx) -> {
+                     when(mocked.getWeblog()).thenReturn(weblog);
+                     when(mocked.getUser()).thenReturn(user);
+                 })) {
+             new PreviewServlet().doGet(request, response);
+         }
+ 
+         verify(response).sendError(HttpServletResponse.SC_NOT_FOUND);
+         verify(response, never()).setContentType(anyString());
+         verify(response, never()).getWriter();
+         verify(response, never()).getOutputStream();
+     }
+ }
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/ResourceServletTest.java
index 000000000,5c1030dff..44eb3c0b9
mode 000000,100644..100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/ResourceServletTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/rendering/servlets/ResourceServletTest.java
@@@ -1,0 -1,158 +1,158 @@@
+ /*
+  * 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
+  *
+  *     https://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.roller.weblogger.ui.rendering.servlets;
+ 
+ import java.io.ByteArrayInputStream;
+ import java.io.ByteArrayOutputStream;
+ import java.nio.charset.StandardCharsets;
+ 
 -import javax.servlet.ServletConfig;
 -import javax.servlet.ServletContext;
 -import javax.servlet.ServletOutputStream;
 -import javax.servlet.WriteListener;
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
++import jakarta.servlet.ServletConfig;
++import jakarta.servlet.ServletContext;
++import jakarta.servlet.ServletOutputStream;
++import jakarta.servlet.WriteListener;
++import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
+ 
+ import org.apache.roller.weblogger.business.MediaFileManager;
+ import org.apache.roller.weblogger.business.Weblogger;
+ import org.apache.roller.weblogger.business.WebloggerFactory;
+ import org.apache.roller.weblogger.business.themes.WeblogCustomTheme;
+ import org.apache.roller.weblogger.pojos.MediaFile;
+ import org.apache.roller.weblogger.pojos.Weblog;
+ import org.apache.roller.weblogger.ui.rendering.util.WeblogResourceRequest;
+ import org.junit.jupiter.api.AfterEach;
+ import org.junit.jupiter.api.BeforeEach;
+ import org.junit.jupiter.api.Test;
+ import org.mockito.MockedConstruction;
+ import org.mockito.MockedStatic;
+ 
+ import static org.junit.jupiter.api.Assertions.assertEquals;
+ import static org.mockito.ArgumentMatchers.anyString;
+ import static org.mockito.ArgumentMatchers.eq;
+ import static org.mockito.Mockito.mock;
+ import static org.mockito.Mockito.mockConstruction;
+ import static org.mockito.Mockito.mockStatic;
+ import static org.mockito.Mockito.never;
+ import static org.mockito.Mockito.verify;
+ import static org.mockito.Mockito.when;
+ 
+ /**
+  * A weblog with a custom theme finds its resources in the media library, so a
+  * resource URL can reach any uploaded file whose original path matches.
+  */
+ class ResourceServletTest {
+ 
+     private MockedStatic<WebloggerFactory> factory;
+     private MediaFileManager media;
+     private Weblog weblog;
+     private ResourceServlet servlet;
+ 
+     @BeforeEach
+     void setUp() throws Exception {
+         media = mock(MediaFileManager.class);
+         Weblogger roller = mock(Weblogger.class);
+         when(roller.getMediaFileManager()).thenReturn(media);
+         factory = mockStatic(WebloggerFactory.class);
+         factory.when(WebloggerFactory::getWeblogger).thenReturn(roller);
+ 
+         weblog = mock(Weblog.class);
+         when(weblog.getTheme()).thenReturn(new WeblogCustomTheme(weblog));
+ 
+         ServletContext context = mock(ServletContext.class);
+         when(context.getMimeType("page.html")).thenReturn("text/html");
+         when(context.getMimeType("/page.html")).thenReturn("text/html");
+         when(context.getMimeType("/css/site.css")).thenReturn("text/css");
+         ServletConfig config = mock(ServletConfig.class);
+         when(config.getServletContext()).thenReturn(context);
+ 
+         servlet = new ResourceServlet();
+         servlet.init(config);
+     }
+ 
+     @AfterEach
+     void tearDown() {
+         factory.close();
+     }
+ 
+     @Test
+     void uploadedDocumentFoundByCustomThemeIsADownload() throws Exception {
+         HttpServletResponse response = serve("/page.html",
+                 "<p>page</p>");
+ 
+         verify(response).setContentType("application/octet-stream");
+         verify(response).setHeader("Content-Disposition",
+                 "attachment; filename=\"/page.html\"");
+         verify(response).setHeader("X-Content-Type-Options", "nosniff");
+         verify(response, never()).setContentType("text/html");
+     }
+ 
+     @Test
+     void customThemeStylesheetKeepsItsType() throws Exception {
+         HttpServletResponse response = serve("/css/site.css", "body {}");
+ 
+         verify(response).setContentType("text/css");
+         verify(response).setHeader("X-Content-Type-Options", "nosniff");
+         verify(response, never()).setHeader(eq("Content-Disposition"), 
anyString());
+     }
+ 
+     private HttpServletResponse serve(String path, String body) throws 
Exception {
+         MediaFile file = mock(MediaFile.class);
+         when(file.getOriginalPath()).thenReturn(path);
+         when(file.getInputStream()).thenReturn(
+                 new 
ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8)));
+         when(media.getMediaFileByOriginalPath(weblog, path)).thenReturn(file);
+ 
+         HttpServletRequest request = mock(HttpServletRequest.class);
+         when(request.getDateHeader("If-Modified-Since")).thenReturn(-1L);
+         HttpServletResponse response = mock(HttpServletResponse.class);
+         ByteArrayOutputStream written = new ByteArrayOutputStream();
+         when(response.getOutputStream()).thenReturn(new 
CapturingStream(written));
+ 
+         try (MockedConstruction<WeblogResourceRequest> parsed = 
mockConstruction(
+                 WeblogResourceRequest.class, (mocked, ctx) -> {
+                     when(mocked.getWeblog()).thenReturn(weblog);
+                     when(mocked.getResourcePath()).thenReturn(path);
+                 })) {
+             servlet.doGet(request, response);
+         }
+ 
+         assertEquals(body, written.toString(StandardCharsets.UTF_8.name()));
+         return response;
+     }
+ 
+     private static final class CapturingStream extends ServletOutputStream {
+         private final ByteArrayOutputStream target;
+ 
+         CapturingStream(ByteArrayOutputStream target) {
+             this.target = target;
+         }
+ 
+         @Override
+         public void write(int b) {
+             target.write(b);
+         }
+ 
+         @Override
+         public boolean isReady() {
+             return true;
+         }
+ 
+         @Override
+         public void setWriteListener(WriteListener listener) {
+         }
+     }
+ }
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEditTest.java
index 000000000,df8ee3f0f..59174430a
mode 000000,100644..100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEditTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/admin/PingTargetEditTest.java
@@@ -1,0 -1,94 +1,94 @@@
+ /*
+  * 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.roller.weblogger.ui.struts2.admin;
+ 
 -import javax.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletRequest;
+ 
+ import org.apache.roller.weblogger.business.Weblogger;
+ import org.apache.roller.weblogger.business.WebloggerFactory;
+ import org.apache.roller.weblogger.business.pings.PingTargetManager;
+ import org.apache.roller.weblogger.pojos.PingTarget;
+ import org.junit.jupiter.api.Test;
+ import org.mockito.MockedStatic;
+ 
+ import static org.junit.jupiter.api.Assertions.assertEquals;
+ import static org.mockito.ArgumentMatchers.any;
+ import static org.mockito.ArgumentMatchers.anyString;
+ import static org.mockito.Mockito.doAnswer;
+ import static org.mockito.Mockito.mock;
+ import static org.mockito.Mockito.mockStatic;
+ import static org.mockito.Mockito.never;
+ import static org.mockito.Mockito.spy;
+ import static org.mockito.Mockito.verify;
+ import static org.mockito.Mockito.when;
+ 
+ class PingTargetEditTest {
+ 
+     @Test
+     void getDoesNotSave() throws Exception {
+         PingTargetManager pingTargets = pingTargetManager();
+         try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class)) {
+             Weblogger weblogger = weblogger(factory, pingTargets);
+             PingTargetEdit action = action("GET");
+ 
+             assertEquals(PingTargetEdit.INPUT, action.execute());
+             verify(pingTargets, never()).savePingTarget(any());
+             verify(weblogger, never()).flush();
+         }
+     }
+ 
+     @Test
+     void postSaves() throws Exception {
+         PingTargetManager pingTargets = pingTargetManager();
+         try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class)) {
+             Weblogger weblogger = weblogger(factory, pingTargets);
+             PingTargetEdit action = action("POST");
+ 
+             assertEquals(PingTargetEdit.SUCCESS, action.execute());
+             verify(pingTargets).savePingTarget(any(PingTarget.class));
+             verify(weblogger).flush();
+         }
+     }
+ 
+     private static PingTargetManager pingTargetManager() throws Exception {
+         PingTargetManager pingTargets = mock(PingTargetManager.class);
+         when(pingTargets.isUrlWellFormed(anyString())).thenReturn(true);
+         when(pingTargets.isHostnameKnown(anyString())).thenReturn(true);
+         return pingTargets;
+     }
+ 
+     private static Weblogger weblogger(MockedStatic<WebloggerFactory> factory,
+             PingTargetManager pingTargets) {
+         Weblogger weblogger = mock(Weblogger.class);
+         when(weblogger.getPingTargetManager()).thenReturn(pingTargets);
+         factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+         return weblogger;
+     }
+ 
+     private static PingTargetEdit action(String method) {
+         PingTargetEdit action = spy(new PingTargetEdit());
+         doAnswer(call -> 
call.getArgument(0)).when(action).getText(anyString(), anyString(), 
anyString());
+         action.setActionName("commonPingTargetAdd");
+         action.getBean().setName("example");
+         action.getBean().setPingUrl("http://ping.example.com/rpc";);
+         HttpServletRequest request = mock(HttpServletRequest.class);
+         when(request.getMethod()).thenReturn(method);
 -        action.setServletRequest(request);
++        action.withServletRequest(request);
+         action.myPrepare();
+         return action;
+     }
+ }
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
index 000000000,7479fb6e0..6c0b0346a
mode 000000,100644..100644
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/ajax/UserDataServletTest.java
@@@ -1,0 -1,132 +1,132 @@@
+ /*
+  * 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.roller.weblogger.ui.struts2.ajax;
+ 
+ import java.io.PrintWriter;
+ import java.io.StringWriter;
+ import java.util.List;
+ 
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
++import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
+ 
+ import org.apache.roller.weblogger.business.UserManager;
+ import org.apache.roller.weblogger.business.Weblogger;
+ import org.apache.roller.weblogger.business.WebloggerFactory;
+ import org.apache.roller.weblogger.pojos.User;
+ import org.apache.roller.weblogger.ui.rendering.util.WeblogRequest;
+ import org.junit.jupiter.api.Test;
+ import org.mockito.MockedConstruction;
+ import org.mockito.MockedStatic;
+ 
+ import static org.junit.jupiter.api.Assertions.assertEquals;
+ import static org.mockito.ArgumentMatchers.any;
+ import static org.mockito.ArgumentMatchers.anyInt;
+ import static org.mockito.ArgumentMatchers.anyString;
+ import static org.mockito.Mockito.mock;
+ import static org.mockito.Mockito.mockConstruction;
+ import static org.mockito.Mockito.mockStatic;
+ import static org.mockito.Mockito.never;
+ import static org.mockito.Mockito.verify;
+ import static org.mockito.Mockito.when;
+ 
+ public class UserDataServletTest {
+ 
+     @Test
+     public void testNonAdminSearchesUserNamesOnly() throws Exception {
+         User caller = mock(User.class);
+         when(caller.hasGlobalPermission("admin")).thenReturn(false);
+         UserManager users = userManager();
+ 
+         String body = search(caller, users);
+ 
+         verify(users).getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 
0, 50);
+         verify(users, never()).getUsersStartingWith(anyString(), any(), 
anyInt(), anyInt());
+         assertEquals("alice,Alice\n", body.replace("\r", ""));
+     }
+ 
+     @Test
+     public void testAdminSearchesUserNamesAndEmail() throws Exception {
+         User caller = mock(User.class);
+         when(caller.hasGlobalPermission("admin")).thenReturn(true);
+         UserManager users = userManager();
+ 
+         String body = search(caller, users);
+ 
+         verify(users).getUsersStartingWith("ali", Boolean.TRUE, 0, 50);
+         verify(users, never()).getUsersWithUserNameStartingWith(anyString(), 
any(), anyInt(), anyInt());
+         assertEquals("alice,[email protected]\n", body.replace("\r", ""));
+     }
+ 
+     @Test
+     public void testNonAdminGetsEnabledUsersOnePageAtATime() throws Exception 
{
+         User caller = mock(User.class);
+         when(caller.hasGlobalPermission("admin")).thenReturn(false);
+         UserManager users = userManager();
+ 
+         search(caller, users, "false", "100000");
+ 
+         verify(users).getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 
0, 50);
+     }
+ 
+     @Test
+     public void testAdminKeepsRequestedParameters() throws Exception {
+         User caller = mock(User.class);
+         when(caller.hasGlobalPermission("admin")).thenReturn(true);
+         UserManager users = userManager();
+ 
+         search(caller, users, "false", "100");
+ 
+         verify(users).getUsersStartingWith("ali", Boolean.FALSE, 0, 100);
+     }
+ 
+     private static UserManager userManager() throws Exception {
+         User alice = mock(User.class);
+         when(alice.getUserName()).thenReturn("alice");
+         when(alice.getScreenName()).thenReturn("Alice");
+         when(alice.getEmailAddress()).thenReturn("[email protected]");
+         UserManager users = mock(UserManager.class);
+         when(users.getUsersStartingWith("ali", Boolean.TRUE, 0, 
50)).thenReturn(List.of(alice));
+         when(users.getUsersWithUserNameStartingWith("ali", Boolean.TRUE, 0, 
50)).thenReturn(List.of(alice));
+         return users;
+     }
+ 
+     private static String search(User caller, UserManager users) throws 
Exception {
+         return search(caller, users, "true", "50");
+     }
+ 
+     private static String search(User caller, UserManager users, String 
enabled, String length)
+             throws Exception {
+         Weblogger weblogger = mock(Weblogger.class);
+         when(weblogger.getUserManager()).thenReturn(users);
+ 
+         HttpServletRequest request = mock(HttpServletRequest.class);
+         when(request.getParameter("startsWith")).thenReturn("ali");
+         when(request.getParameter("enabled")).thenReturn(enabled);
+         when(request.getParameter("length")).thenReturn(length);
+         HttpServletResponse response = mock(HttpServletResponse.class);
+         StringWriter body = new StringWriter();
+         when(response.getWriter()).thenReturn(new PrintWriter(body, true));
+ 
+         try (MockedStatic<WebloggerFactory> factory = 
mockStatic(WebloggerFactory.class);
+              MockedConstruction<WeblogRequest> weblogRequests = 
mockConstruction(WeblogRequest.class,
+                      (weblogRequest, context) -> 
when(weblogRequest.getUser()).thenReturn(caller))) {
+             
factory.when(WebloggerFactory::getWeblogger).thenReturn(weblogger);
+             new UserDataServlet().doGet(request, response);
+         }
+         return body.toString();
+     }
+ }
diff --cc 
app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
index 89b2ab958,91a869d25..ecbad6c4e
--- 
a/app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
+++ 
b/app/src/test/java/org/apache/roller/weblogger/ui/struts2/util/ValidateSaltInterceptorTest.java
@@@ -19,8 -19,9 +19,9 @@@
  
  package org.apache.roller.weblogger.ui.struts2.util;
  
 -import javax.servlet.ServletException;
 -import javax.servlet.http.HttpServletRequest;
 -import javax.servlet.http.HttpServletResponse;
 +import jakarta.servlet.ServletException;
 +import jakarta.servlet.http.HttpServletRequest;
++import jakarta.servlet.http.HttpServletResponse;
  
  import org.apache.roller.weblogger.pojos.User;
  import org.apache.roller.weblogger.ui.core.RollerSession;
@@@ -34,8 -35,10 +35,10 @@@ import org.mockito.Mock
  import org.mockito.MockedStatic;
  import org.mockito.MockitoAnnotations;
  
 -import com.opensymphony.xwork2.Action;
 -import com.opensymphony.xwork2.ActionContext;
 -import com.opensymphony.xwork2.ActionInvocation;
 -import com.opensymphony.xwork2.ActionProxy;
 +import org.apache.struts2.ActionContext;
 +import org.apache.struts2.ActionInvocation;
++import org.apache.struts2.ActionProxy;
++import org.apache.struts2.action.Action;
  
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertEquals;

Reply via email to