com.github.tomakehurst.wiremock.common.FileSource Java Examples

@Override
public Response transform(Request request, Response response,
        FileSource files, Parameters parameters) {
    if (redirects == null) {
        redirects = parameters.getInt("redirects");
    }
    String nl;
    if (redirects > 1) {
        redirects--;
        nl = "/" + REDIRECT + "?r=" + redirects;
    } else {
        nl = "/" + TEST_FILE_NAME;
    }
    return Response.Builder.like(response)
            .but().headers(response.getHeaders()
                    .plus(new HttpHeader("Location", nl)))
            .build();
}
 

@Override
public Response transform(Request request, Response response, FileSource files,
                          Parameters parameters) {
    if ("application/json"
        .equals(response.getHeaders().getContentTypeHeader().mimeTypePart())) {
        return Response.Builder.like(response)
            .but()
            .body(response.getBodyAsString()
                .replace("https://api.github.com/",
                    "http://localhost:" + githubApi.port() + "/")
                .replace("https://raw.githubusercontent.com/",
                    "http://localhost:" + githubRaw.port() + "/")
            )
            .build();
    }
    return response;
}
 

@Override
public FileSource child(String subDirectoryName) {
	List<FileSource> childSources = new ArrayList<>();
	for (FileSource resource : this.sources) {
		try {
			UrlResource uri = new UrlResource(
					resource.child(subDirectoryName).getUri());
			if (uri.createRelative(subDirectoryName).exists()) {
				childSources.add(resource.child(subDirectoryName));
			}
		}
		catch (IOException e) {
			// Ignore
		}
	}
	if (!childSources.isEmpty()) {
		return new ResourcesFileSource(childSources.toArray(new FileSource[0]));
	}
	return this.sources[0].child(subDirectoryName);
}
 

private static FileSource[] toSources(Resource[] resources) {
	FileSource[] sources = new FileSource[resources.length];
	for (int i = 0; i < resources.length; i++) {
		Resource resource = resources[i];
		if (resource instanceof ClassPathResource) {
			ClassPathResource classes = (ClassPathResource) resource;
			sources[i] = new ClasspathFileSource(classes.getPath());
		}
		else if (resource instanceof FileSystemResource) {
			FileSystemResource files = (FileSystemResource) resource;
			sources[i] = new SingleRootFileSource(files.getFile());
		}
		else if (resource instanceof UrlResource) {
			sources[i] = fileOrFallbackToClasspath(resource);
		}
		else {
			throw new IllegalArgumentException(
					"Unsupported resource type for file source: "
							+ resource.getClass());
		}
	}
	return sources;
}
 

@Override
public com.github.tomakehurst.wiremock.http.Response transform(
        Request request, com.github.tomakehurst.wiremock.http.Response response, FileSource files,
        Parameters parameters) {

    final String newResponse;
    try {
        newResponse = cacheResponseFromRequestJson(request.getBodyAsString(),
                parameters.getString("matcherName"));
    } catch (IOException e) {
        return com.github.tomakehurst.wiremock.http.Response.response()
                .body(e.getMessage())
                .status(500)
                .build();
    }
    return com.github.tomakehurst.wiremock.http.Response.response().body(newResponse).status(200).build();
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
    // if gzipped, ungzip they body and discard the Content-Encoding header
    if (response.getHeaders().getHeader("Content-Encoding").containsValue("gzip")) {
        Iterable<HttpHeader> headers = Iterables.filter(
            response.getHeaders().all(),
            (HttpHeader header) -> header != null && !header.keyEquals("Content-Encoding") && !header.containsValue("gzip")
        );
        return Response.Builder.like(response)
            .but()
            .body(Gzip.unGzip(response.getBody()))
            .headers(new HttpHeaders(headers))
            .build();
    }
    return response;
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
    if ("application/json"
        .equals(response.getHeaders().getContentTypeHeader().mimeTypePart())) {
        return Response.Builder.like(response)
            .but()
            .body(response.getBodyAsString().replace(sourceUrl, getServerUrl(rule)))
            .build();
    }
    return response;
}
 

private String getResponseBody(ResponseDefinition responseDefinition, FileSource fileSource) {
    String body;
    if (responseDefinition.getBody() != null) {
        body = responseDefinition.getBody();
    } else {
        BinaryFile binaryFile = fileSource.getBinaryFileNamed(responseDefinition.getBodyFileName());
        body = new String(binaryFile.readContents(), StandardCharsets.UTF_8);
    }
    return body;
}
 

@Override
public boolean exists() {
	for (FileSource resource : this.sources) {
		if (resource.exists()) {
			return true;
		}
	}
	return false;
}
 

@Override
public List<TextFile> listFilesRecursively() {
	List<TextFile> files = new ArrayList<>();
	for (FileSource resource : this.sources) {
		files.addAll(resource.listFilesRecursively());
	}
	return files;
}
 

@Override
public URI getUri() {
	for (FileSource resource : this.sources) {
		try {
			UrlResource uri = new UrlResource(resource.getUri());
			if (uri.exists()) {
				return resource.getUri();
			}
		}
		catch (IOException e) {
			// Ignore
		}
	}
	return this.sources[0].getUri();
}
 

@Override
public String getPath() {
	for (FileSource resource : this.sources) {
		try {
			UrlResource uri = new UrlResource(resource.getUri());
			if (uri.exists()) {
				return resource.getPath();
			}
		}
		catch (IOException e) {
			// Ignore
		}
	}
	return this.sources[0].getPath();
}
 

@Override
public TextFile getTextFileNamed(String name) {
	for (FileSource resource : this.sources) {
		TextFile file = resource.getTextFileNamed(name);
		try {
			file.readContentsAsString();
			return file;
		}
		catch (RuntimeException e) {
			// Ignore
		}
	}
	return null;
}
 

@Override
public BinaryFile getBinaryFileNamed(String name) {
	for (FileSource resource : this.sources) {
		try {
			UrlResource uri = new UrlResource(resource.getUri());
			if (uri.exists()) {
				return resource.getBinaryFileNamed(name);
			}
		}
		catch (IOException e) {
			// Ignore
		}
	}
	throw new IllegalStateException("Cannot create file for " + name);
}
 

private static FileSource fileOrFallbackToClasspath(Resource resource) {
	UrlResource file = (UrlResource) resource;
	try {
		URI uri = file.getURI();
		if (compressedResource(uri)) {
			return new ClasspathFileSource(pathFromCompressed(uri));
		}
		return new SingleRootFileSource(getFile(file));
	}
	catch (IOException e) {
		throw new IllegalStateException(e);
	}
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
        final FileSource files, final Parameters parameters) {
    final String subject = Iterables.get(this.urlSplitter.split(request.getUrl()), 1);
    try {
        final int id = SchemaRegistryMock.this.register(subject,
                new Schema.Parser()
                        .parse(RegisterSchemaRequest.fromJson(request.getBodyAsString()).getSchema()));
        final RegisterSchemaResponse registerSchemaResponse = new RegisterSchemaResponse();
        registerSchemaResponse.setId(id);
        return ResponseDefinitionBuilder.jsonResponse(registerSchemaResponse);
    } catch (final IOException e) {
        throw new IllegalArgumentException("Cannot parse schema registration request", e);
    }
}
 

@Override
public Response transform(Request request, Response response, FileSource files,
                          Parameters parameters) {
    if ("application/json"
            .equals(response.getHeaders().getContentTypeHeader().mimeTypePart())) {
        return Response.Builder.like(response)
                .but()
                .body(response.getBodyAsString()
                        .replace("https://api.github.com/",
                                "http://localhost:" + githubApi.port() + "/")
                )
                .build();
    }
    return response;
}
 

@Override
public Response transform(Request request, Response response, FileSource files, Parameters parameters) {
    return Response.Builder.like(response)
                           .headers(HttpHeaders.copyOf(response.getHeaders())
                                               .plus(new HttpHeader("Connection", "Close")))
                           .build();
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
                                    final FileSource files, final Parameters parameters) {
    String versionStr = Iterables.get(this.urlSplitter.split(request.getUrl()), 3);
    SchemaMetadata metadata;
    if (versionStr.equals("latest")) {
        metadata = SchemaRegistryMock.this.getSubjectVersion(getSubject(request), versionStr);
    } else {
        int version = Integer.parseInt(versionStr);
        metadata = SchemaRegistryMock.this.getSubjectVersion(getSubject(request), version);
    }
    return ResponseDefinitionBuilder.jsonResponse(metadata);
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
                                    final FileSource files, final Parameters parameters) {
    final List<Integer> versions = SchemaRegistryMock.this.listVersions(getSubject(request));
    log.debug("Got versions {}", versions);
    return ResponseDefinitionBuilder.jsonResponse(versions);
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
                                    final FileSource files, final Parameters parameters) {
    try {
        final int id = SchemaRegistryMock.this.register(getSubject(request),
                new Schema.Parser()
                        .parse(RegisterSchemaRequest.fromJson(request.getBodyAsString()).getSchema()));
        final RegisterSchemaResponse registerSchemaResponse = new RegisterSchemaResponse();
        registerSchemaResponse.setId(id);
        return ResponseDefinitionBuilder.jsonResponse(registerSchemaResponse);
    } catch (final IOException e) {
        throw new IllegalArgumentException("Cannot parse schema registration request", e);
    }
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
        final FileSource files, final Parameters parameters) {
    final String versionStr = Iterables.get(this.urlSplitter.split(request.getUrl()), 3);
    final SchemaMetadata metadata;
    if (versionStr.equals("latest")) {
        metadata = SchemaRegistryMock.this.getSubjectVersion(this.getSubject(request), versionStr);
    } else {
        final int version = Integer.parseInt(versionStr);
        metadata = SchemaRegistryMock.this.getSubjectVersion(this.getSubject(request), version);
    }
    return ResponseDefinitionBuilder.jsonResponse(metadata);
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
        final FileSource files, final Parameters parameters) {
    final List<Integer> versions = SchemaRegistryMock.this.listVersions(this.getSubject(request));
    log.debug("Got versions {}", versions);
    return ResponseDefinitionBuilder.jsonResponse(versions);
}
 

private ResourcesFileSource(FileSource... sources) {
	this.sources = sources;
}
 

@Override
public FileSource child(String subDirectoryName) {
    return new ServletContextFileSource(rootPath + '/' + subDirectoryName);
}
 

@Override
public FileSource filesRoot() {
    return new ServletContextFileSource(fileSourceRoot);
}
 

@Override
public ResponseDefinition transform(
    final Request request,
    final ResponseDefinition responseDefinition,
    final FileSource files,
    final Parameters parameters
) throws RuntimeException {
    final VelocityEngine velocityEngine = new VelocityEngine();
    velocityEngine.init();
    final ToolManager toolManager = new ToolManager();
    toolManager.setVelocityEngine(velocityEngine);

    context = toolManager.createContext();
    URL url = getRequestUrl(request);
    addBodyToContext(request.getBodyAsString());
    addHeadersToContext(request.getHeaders());
    context.put("requestAbsoluteUrl", request.getAbsoluteUrl());
    context.put("requestUrl", request.getUrl());
    context.put("requestMethod", request.getMethod());
    context.put("queryParams", urlExtractor.extractQueryParameters(url));
    context.put("pathSegments", urlExtractor.extractPathSegments(url));
    context.put("staticContext", staticContexts.computeIfAbsent(url.getPath(), k -> new HashMap<>()));
    context.put(ExtendedScript.MQ_PROPERTIES, properties);

    String body;
    if (responseDefinition.specifiesBodyFile() && templateDeclared(responseDefinition)) {
        body = getRenderedBody(responseDefinition);
    } else if (responseDefinition.specifiesBodyContent()) {
        try {
            body = getRenderedBodyFromFile(responseDefinition);
        } catch (ParseException e) {
            body = e.getMessage();
            e.printStackTrace();
        }
    } else {
        return responseDefinition;
    }
    if (isPresentConvertCommand(responseDefinition.getHeaders().getHeader(MultipartConstant.CONVERT_BASE64_IN_MULTIPART.getValue()))) {
        log.info(" >>> ");
        log.info(body);
        return buildResponse(parseConvertBody(body), body, responseDefinition, true);
    }
    return buildResponse(null, body, responseDefinition, false);
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
                                    final FileSource files, final Parameters parameters) {
    Config config = new Config(SchemaRegistryMock.this.getCompatibility(getSubject(request)));
    return ResponseDefinitionBuilder.jsonResponse(config);
}
 

@Override
public ResponseDefinition transform(final Request request, final ResponseDefinition responseDefinition,
        final FileSource files, final Parameters parameters) {
    final Collection<String> body = SchemaRegistryMock.this.listAllSubjects();
    return ResponseDefinitionBuilder.jsonResponse(body);
}
 

@Override
public FileSource child(String name) {
    return new AndroidAssetsReadOnlyFileSource(assetManager, name);
}