assert output response sling servlet filter

Question

I am trying to assert output of the below transformed response from sling servlet filter. I am not able to get hold of output response and not able to assert.

  import com.day.cq.wcm.api.Page;
  import com.safeway.app.rxwa.pharmacy.utils.HttpServletResponseCopier;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.sling.api.SlingHttpServletRequest;
  import org.apache.sling.api.SlingHttpServletResponse;
  import org.apache.sling.api.request.RequestPathInfo;
  import org.apache.sling.api.resource.Resource;
  import org.apache.sling.api.resource.ResourceResolverFactory;
  import org.apache.sling.engine.EngineConstants;
  import org.osgi.service.component.annotations.Activate;
  import org.osgi.service.component.annotations.Component;
  import org.osgi.service.component.annotations.ConfigurationPolicy;
  import org.osgi.service.component.annotations.Reference;
  import org.osgi.service.metatype.annotations.AttributeDefinition;
  import org.osgi.service.metatype.annotations.Designate;
   import org.osgi.service.metatype.annotations.ObjectClassDefinition;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;

 import javax.servlet.*;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;

   /**
    * This filter rewrites link for the Content Fragment list model exporter
  */
 @Component(service = Filter.class,
    immediate = true,
    configurationPolicy = ConfigurationPolicy.REQUIRE,
    property = {
            EngineConstants.SLING_FILTER_SCOPE + "=" + EngineConstants.FILTER_SCOPE_REQUEST,
            EngineConstants.SLING_FILTER_METHODS + "=GET",
            EngineConstants.SLING_FILTER_PATTERN + "=/content/experience-fragments/rxwa/.*",
            EngineConstants.SLING_FILTER_SELECTORS + "=model",
            EngineConstants.SLING_FILTER_EXTENSIONS + "=json"})

   @Designate(ocd = ContentJsonLinkRewriterFilter.Config.class)
  public class ContentJsonLinkRewriterFilter implements Filter {

   private static final Logger logger = 
LoggerFactory.getLogger(ContentJsonLinkRewriterFilter.class);

private Config config;
private List<String> resourceTypes;

@Reference
private ResourceResolverFactory resolverFactory;

@Activate
public void activate(Config config) {
    this.config = config;
    this.resourceTypes = Arrays.asList(config.resourceTypes());
}

@Override
public void init(FilterConfig filterConfig) throws ServletException {
    // no-op
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {


    String resultString = "{}";

    // add author check
    if (!(response instanceof SlingHttpServletResponse) || !(request instanceof SlingHttpServletRequest)) {
        throw new IllegalStateException("Filter not properly registered as Sling Servlet Filter");
    }

    if (!config.enabled()) {
        logger.debug("Filter disabled");
        filterChain.doFilter(request, response);
        return;
    }

    SlingHttpServletRequest slingHttpServletRequest = (SlingHttpServletRequest) request;

    Resource currentResource = slingHttpServletRequest.getResource();
    String currentResourceType = currentResource.getResourceType();

    if(currentResource.isResourceType("cq:Page")) {
        Page page = slingHttpServletRequest.getResource().adaptTo(Page.class);
        currentResourceType = page.getContentResource().getResourceType();
    }

    String finalProcessResourceType = currentResourceType;

    if (resourceTypes.stream().noneMatch(resourceType -> StringUtils.startsWith(finalProcessResourceType, resourceType))) {
        logger.debug("Current resource path {} is not configured to be evaluated", currentResourceType);
        filterChain.doFilter(request, response);
        return;
    }

    // Wrap Response Class before servlet gets called
    HttpServletResponseCopier responseCopier = new HttpServletResponseCopier((SlingHttpServletResponse) response);

    filterChain.doFilter(request, responseCopier);

    // externalize links after the servlet finishes
    responseCopier.flushBuffer();
    //read original response
    byte[] responseBytes = responseCopier.getCopy();
    String responseString = new String(responseBytes, responseCopier.getCharacterEncoding());

    if (StringUtils.isNotEmpty(responseString)) {
        //replace all links
        resultString = responseString.replaceAll(StringUtils.substring(slingHttpServletRequest.getRequestURI(),0, slingHttpServletRequest.getRequestURI().lastIndexOf("/")), "");
    }

    responseCopier.resetBuffer();
    responseCopier.getOutputStream().write(resultString.getBytes());
    responseCopier.setContentType("application/json");
    responseCopier.setCharacterEncoding("utf-8");
}

@Override
public void destroy() {
    // no-op
}

@ObjectClassDefinition(name = "Content Fragment List Link Rewriter Filter",
        description = "Configuration for filter to extend Content Fragment List functionality to rewrite links")
public @interface Config {
    @AttributeDefinition(name = "Enabled",
            description = "If this filter should not be active, rather try to delete this config. " + "Only in cases " +
                    "where this cannot be easily accomplished uncheck this option to disable the filter.") boolean enabled() default false;

    @AttributeDefinition(name = "Resource Types",
            description = "Resource Types to be evaluated by the filter.") String[] resourceTypes();
}

}

Unit test I tried

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

import com.safeway.app.rxwa.pharmacy.utils.HttpServletResponseCopier;
import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.commons.io.IOUtils;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.testing.mock.osgi.MapUtil;
import org.apache.sling.testing.mock.sling.loader.ContentLoader;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletRequest;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;

import com.day.cq.commons.jcr.JcrConstants;
import com.day.cq.wcm.api.components.ComponentContext;
import com.day.cq.wcm.api.designer.Design;
import com.day.cq.wcm.api.designer.Designer;
import com.google.common.collect.Sets;
import org.mockito.junit.MockitoJUnitRunner;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

@RunWith(MockitoJUnitRunner.class)
public class ContentJsonLinkRewriterFilterTest {
    protected static final String CONTENT_ROOT = "/content/experience-fragments/rxwa";

    public Map<String, Object> props = new HashMap<>();

    @Rule
    public AemContext context = new AemContext();

    @Mock
    FilterChain chain;

    public ContentJsonLinkRewriterFilter filter;

    @Before
    public void setUp() {
            context.load().json("/test-page-content.json", "/content/experience- 
 fragments/rxwa");

            props.clear();
            props.put("enabled", "true");
            props.put("resourceTypes", new String[] {"rxwa- 
    pharmacy/components/structure/xfpage"});
     ContentJsonLinkRewriterFilter aei = context.registerInjectActivateService(new 
      ContentJsonLinkRewriterFilter(), props);
            filter = Mockito.spy(aei);
    }

    @Test
    public void doFilterCall() throws ServletException, IOException {

    context.requestPathInfo().setResourcePath("/content/experience-fragments/rxwa/templated- 
  page");
            context.requestPathInfo().setSelectorString("model");
            context.requestPathInfo().setExtension("json");
            context.request().setMethod("GET");

            context.response().setCharacterEncoding("UTF-8");

            context.currentPage("/content/experience-fragments/rxwa/templated-page");

            Mockito.doAnswer(invocation -> {
                    HttpServletResponseWrapper httpServletResponseWrapper =
                            (HttpServletResponseWrapper) invocation.getArguments()[1];
                    String testHtmlContent = IOUtils.toString(                                 
    ContentLoader.class.getResourceAsStream("/test-page-content.json"),
                            StandardCharsets.UTF_8
                    );
                    httpServletResponseWrapper.getWriter()
                            .write(testHtmlContent);
                    httpServletResponseWrapper.getWriter().flush();

                    return null;
            }).when(chain).doFilter(Mockito.any(), Mockito.any());



            filter.doFilter(context.request(), context.response(), chain);

            Mockito.verify(chain).doFilter(Mockito.any(), Mockito.any());

            String testHtmlContent2 = IOUtils.toString(
                    ContentLoader.class.getResourceAsStream("/test-page-content.json"),
                    StandardCharsets.UTF_8
            );
      }

 }