getPartStreams() {
91 | return Collections.unmodifiableList(partStreams);
92 | }
93 |
94 | void reset(final PartStreamImpl newPart) {
95 | buffering = true;
96 | partBytesRead = 0;
97 | currentPart = newPart;
98 | partStreams.add(newPart);
99 | output = null;
100 | }
101 |
102 | void setOutput(final PartOutput output) {
103 | this.output = output;
104 | this.currentPart.setOutput(output);
105 | }
106 |
107 | boolean isBuffering() {
108 | return buffering;
109 | }
110 |
111 | void finishBuffering() {
112 | buffering = false;
113 | }
114 |
115 | void updatePartBytesRead() {
116 | currentPart.setSize(partBytesRead);
117 | }
118 |
119 | int getPartBytesRead() {
120 | return partBytesRead;
121 | }
122 |
123 | int incrementAndGetPartBytesRead(final int additional) {
124 | partBytesRead += additional;
125 | return partBytesRead;
126 | }
127 | }
128 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/internal/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * The package for the actual implementation. Classes of this
3 | * package are considered internal, can change a lot during
4 | * releases, but are otherwise usable. If the public API
5 | * does not meet the needs then these classes can be used
6 | * instead.
7 | */
8 | package com.github.elopteryx.upload.internal;
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * The top level of the package hierarchy which contains the
3 | * public API of this library. Interfaces and classes here will
4 | * not be changed frequently.
5 | *
6 | * The library has been designed to hide the implementation details
7 | * from the users. When using it the users should not
8 | * need to import from the internal package, using the public
9 | * classes and the exception classes should be more than enough.
10 | *
11 | * The parser object provides full control over the uploading
12 | * process. The functional interfaces can be used to perform
13 | * operations on the part objects. Information about the process
14 | * is provided in the upload context object, which is available
15 | * in every stage of the process.
16 | *
17 | * The classes here have been designed to work with servlets. There
18 | * are two kinds of parsing, you can do it asynchronously or in
19 | * a blocking way. For the former the servlet must support support
20 | * async mode. Both of them are incompatible with the multipart
21 | * API of the servlet specification. Using that makes the
22 | * servlet input stream unavailable for this library or any code
23 | * that is written by the users.
24 | */
25 | package com.github.elopteryx.upload;
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/ByteBufferBackedInputStream.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2016 Adam Forgacs
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.github.elopteryx.upload.util;
18 |
19 | import java.io.IOException;
20 | import java.io.InputStream;
21 | import java.nio.ByteBuffer;
22 | import java.util.Objects;
23 |
24 | /**
25 | * An input stream implementation which reads from the given byte buffer.
26 | * The stream will not copy bytes to a temporary buffer, therefore read-only
27 | * and direct buffers are not supported.
28 | */
29 | public class ByteBufferBackedInputStream extends InputStream {
30 |
31 | /**
32 | * The byte buffer. Cannot be read-only or direct.
33 | */
34 | private final ByteBuffer buffer;
35 |
36 | /**
37 | * Flag to determine whether the channel is closed or not.
38 | */
39 | private boolean open = true;
40 |
41 | /**
42 | * Public constructor.
43 | * @param buffer The byte buffer
44 | */
45 | public ByteBufferBackedInputStream(final ByteBuffer buffer) {
46 | this.buffer = Objects.requireNonNull(buffer);
47 | if (buffer.isDirect() || buffer.isReadOnly()) {
48 | throw new IllegalArgumentException("The buffer cannot be direct or read-only!");
49 | }
50 | }
51 |
52 | @Override
53 | public int available() throws IOException {
54 | return buffer.remaining();
55 | }
56 |
57 | @Override
58 | public int read() throws IOException {
59 | if (!open) {
60 | throw new IOException("The stream was closed!");
61 | }
62 | if (!buffer.hasRemaining()) {
63 | return -1;
64 | }
65 | return buffer.get() & 0xFF;
66 | }
67 |
68 | @Override
69 | public int read(final byte[] bytes, final int off, int len) throws IOException {
70 | if (!open) {
71 | throw new IOException("The stream was closed!");
72 | }
73 | if (!buffer.hasRemaining()) {
74 | return -1;
75 | }
76 | len = Math.min(len, buffer.remaining());
77 | buffer.get(bytes, off, len);
78 | return len;
79 | }
80 |
81 | @Override
82 | public void close() throws IOException {
83 | open = false;
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/ByteBufferBackedOutputStream.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import java.io.IOException;
4 | import java.io.OutputStream;
5 | import java.nio.ByteBuffer;
6 | import java.util.Objects;
7 |
8 | /**
9 | * An output stream implementation which writes to the given byte buffer.
10 | * The stream will not copy bytes to a temporary buffer, therefore read-only
11 | * and direct buffers are not supported.
12 | */
13 | public class ByteBufferBackedOutputStream extends OutputStream {
14 |
15 | /**
16 | * The byte buffer. Cannot be read-only or direct.
17 | */
18 | private final ByteBuffer buffer;
19 |
20 | /**
21 | * Flag to determine whether the channel is closed or not.
22 | */
23 | private boolean open = true;
24 |
25 | /**
26 | * Public constructor.
27 | * @param buffer The byte buffer
28 | */
29 | public ByteBufferBackedOutputStream(final ByteBuffer buffer) {
30 | this.buffer = Objects.requireNonNull(buffer);
31 | if (buffer.isDirect() || buffer.isReadOnly()) {
32 | throw new IllegalArgumentException("The buffer cannot be direct or read-only!");
33 | }
34 | }
35 |
36 | @Override
37 | public void write(final int byteToWrite) throws IOException {
38 | if (!open) {
39 | throw new IOException("The stream was closed!");
40 | }
41 | buffer.put((byte) byteToWrite);
42 | }
43 |
44 | @Override
45 | public void write(final byte[] bytes, final int off, final int len) throws IOException {
46 | if (!open) {
47 | throw new IOException("The stream was closed!");
48 | }
49 | buffer.put(bytes, off, len);
50 | }
51 |
52 | @Override
53 | public void close() throws IOException {
54 | open = false;
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/InputStreamBackedChannel.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import java.io.IOException;
4 | import java.io.InputStream;
5 | import java.nio.ByteBuffer;
6 | import java.nio.channels.ClosedChannelException;
7 | import java.nio.channels.ReadableByteChannel;
8 | import java.util.Objects;
9 |
10 | /**
11 | * A channel implementation which reads the ByteBuffer
12 | * data from the given InputStream instance.
13 | *
14 | * This implementation differs from the one returned
15 | * in {@link java.nio.channels.Channels#newChannel(InputStream)}
16 | * by one notable thing, it does not use a temporary buffer, because
17 | * it will not handle read-only or direct ByteBuffers.
18 | *
19 | * The channel honors the close contract, it cannot be used after closing.
20 | */
21 | public class InputStreamBackedChannel implements ReadableByteChannel {
22 |
23 | /**
24 | * Flag to determine whether the channel is closed or not.
25 | */
26 | private boolean open = true;
27 |
28 | /**
29 | * The stream the channel will read from.
30 | */
31 | private final InputStream inputStream;
32 |
33 | /**
34 | * Public constructor.
35 | * @param inputStream The input stream
36 | */
37 | public InputStreamBackedChannel(final InputStream inputStream) {
38 | this.inputStream = Objects.requireNonNull(inputStream);
39 | }
40 |
41 | @Override
42 | public int read(final ByteBuffer dst) throws IOException {
43 | if (!open) {
44 | throw new ClosedChannelException();
45 | }
46 | if (dst.isDirect() || dst.isReadOnly()) {
47 | throw new IllegalArgumentException("The buffer cannot be direct or read-only!");
48 | }
49 | final var buf = dst.array();
50 | final var offset = dst.position();
51 | final var len = dst.remaining();
52 | final var read = inputStream.read(buf, offset, len);
53 | dst.position(offset + read);
54 | return read;
55 | }
56 |
57 | @Override
58 | public boolean isOpen() {
59 | return open;
60 | }
61 |
62 | @Override
63 | public void close() throws IOException {
64 | inputStream.close();
65 | open = false;
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/NullChannel.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2016 Adam Forgacs
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.github.elopteryx.upload.util;
18 |
19 | import com.github.elopteryx.upload.OnPartBegin;
20 |
21 | import java.io.IOException;
22 | import java.nio.ByteBuffer;
23 | import java.nio.channels.ClosedChannelException;
24 | import java.nio.channels.ReadableByteChannel;
25 | import java.nio.channels.WritableByteChannel;
26 |
27 | /**
28 | * A channel implementation which provides no data and discards the data supplied.
29 | * Used by the parser if it doesn't have a channel to write to.
30 | * The purpose of this is to make the {@link OnPartBegin} callback
31 | * optional, which is useful for testing.
32 | *
33 | * The channel honors the close contract, it cannot be used after closing.
34 | */
35 | public class NullChannel implements ReadableByteChannel, WritableByteChannel {
36 |
37 | /**
38 | * Flag to determine whether the channel is closed or not.
39 | */
40 | private boolean open = true;
41 |
42 | @Override
43 | public int read(final ByteBuffer dst) throws IOException {
44 | if (!open) {
45 | throw new ClosedChannelException();
46 | }
47 | return -1;
48 | }
49 |
50 | @Override
51 | public int write(final ByteBuffer src) throws IOException {
52 | if (!open) {
53 | throw new ClosedChannelException();
54 | }
55 | final var remaining = src.remaining();
56 | src.position(src.limit());
57 | return remaining;
58 | }
59 |
60 | @Override
61 | public boolean isOpen() {
62 | return open;
63 | }
64 |
65 | @Override
66 | public void close() {
67 | open = false;
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/OutputStreamBackedChannel.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2016 Adam Forgacs
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.github.elopteryx.upload.util;
18 |
19 | import java.io.IOException;
20 | import java.io.OutputStream;
21 | import java.nio.ByteBuffer;
22 | import java.nio.channels.ClosedChannelException;
23 | import java.nio.channels.WritableByteChannel;
24 | import java.util.Objects;
25 |
26 | /**
27 | * A channel implementation which writes the ByteBuffer data
28 | * to the given OutputStream instance.
29 | *
30 | * This implementation differs from the one returned
31 | * in {@link java.nio.channels.Channels#newChannel(OutputStream)}
32 | * by one notable thing, it does not use a temporary buffer, because
33 | * it will not handle read-only or direct ByteBuffers.
34 | *
35 | * The channel honors the close contract, it cannot be used after closing.
36 | */
37 | public class OutputStreamBackedChannel implements WritableByteChannel {
38 |
39 | /**
40 | * Flag to determine whether the channel is closed or not.
41 | */
42 | private boolean open = true;
43 |
44 | /**
45 | * The stream the channel will write to.
46 | */
47 | private final OutputStream outputStream;
48 |
49 | /**
50 | * Public constructor.
51 | * @param outputStream The output stream
52 | */
53 | public OutputStreamBackedChannel(final OutputStream outputStream) {
54 | this.outputStream = Objects.requireNonNull(outputStream);
55 | }
56 |
57 | @Override
58 | public int write(final ByteBuffer src) throws IOException {
59 | if (!open) {
60 | throw new ClosedChannelException();
61 | }
62 | if (src.isDirect() || src.isReadOnly()) {
63 | throw new IllegalArgumentException("The buffer cannot be direct or read-only!");
64 | }
65 | final var buf = src.array();
66 | final var offset = src.position();
67 | final var len = src.remaining();
68 | outputStream.write(buf, offset, len);
69 | src.position(offset + len);
70 | return len;
71 | }
72 |
73 | @Override
74 | public boolean isOpen() {
75 | return open;
76 | }
77 |
78 | @Override
79 | public void close() throws IOException {
80 | outputStream.close();
81 | open = false;
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/com/github/elopteryx/upload/util/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * This package contains utility classes for channels and
3 | * streams used by this library. As they can be useful
4 | * not just for the internal implementation these classes
5 | * have their own package and can be used safely.
6 | */
7 | package com.github.elopteryx.upload.util;
--------------------------------------------------------------------------------
/upload-parser-core/src/main/java/module-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Async file upload module for servlets.
3 | */
4 | module com.github.elopteryx.upload {
5 | requires jakarta.servlet;
6 | exports com.github.elopteryx.upload;
7 | exports com.github.elopteryx.upload.errors;
8 | exports com.github.elopteryx.upload.util;
9 | }
--------------------------------------------------------------------------------
/upload-parser-tests/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id 'jacoco-report-aggregation'
3 | }
4 |
5 | dependencies {
6 |
7 | /* Upload parser. */
8 | implementation(project(':upload-parser-core'))
9 |
10 | /* Test runner. */
11 | testImplementation("org.junit.jupiter:junit-jupiter-api:$junitVersion")
12 | testImplementation("org.junit.jupiter:junit-jupiter-params:$junitVersion")
13 | testImplementation("org.junit.jupiter:junit-jupiter-engine:$junitVersion")
14 |
15 | /* Undertow Http server. */
16 | testImplementation("io.undertow:undertow-core:$undertowVersion")
17 | testImplementation("io.undertow:undertow-servlet:$undertowVersion")
18 |
19 | /* Jetty Http server. */
20 | testImplementation("org.eclipse.jetty:jetty-server:$jettyVersion")
21 | testImplementation("org.eclipse.jetty:jetty-servlet:$jettyVersion")
22 |
23 | /* Tomcat Http server. */
24 | testImplementation("org.apache.tomcat.embed:tomcat-embed-core:$tomcatVersion")
25 |
26 | /* Document and file parser. */
27 | testImplementation("org.apache.tika:tika-core:$tikaVersion")
28 | testImplementation("org.apache.tika:tika-parsers:$tikaVersion")
29 |
30 | /* In-memory filesystem. */
31 | testImplementation("com.google.jimfs:jimfs:$jimfsVersion")
32 |
33 | /* Object mocking. */
34 | testImplementation("org.mockito:mockito-core:$mockitoVersion")
35 |
36 | /* Servlet API. */
37 | testImplementation("jakarta.servlet:jakarta.servlet-api:$servletApiVersion")
38 |
39 | }
40 |
41 | tasks.named('check') {
42 | dependsOn tasks.named('testCodeCoverageReport', JacocoReport)
43 | }
44 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/PartOutputTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertFalse;
4 | import static org.junit.jupiter.api.Assertions.assertNotNull;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 |
7 | import org.junit.jupiter.api.Test;
8 |
9 | import java.io.ByteArrayOutputStream;
10 | import java.io.OutputStream;
11 | import java.nio.channels.Channel;
12 | import java.nio.channels.Channels;
13 | import java.nio.channels.WritableByteChannel;
14 | import java.nio.file.Path;
15 | import java.nio.file.Paths;
16 |
17 | class PartOutputTest {
18 |
19 | @Test
20 | void create_channel_output() {
21 | final var byteArrayOutputStream = new ByteArrayOutputStream();
22 | final var channel = Channels.newChannel(byteArrayOutputStream);
23 | final var output = PartOutput.from(channel);
24 |
25 | assertTrue(output.safeToCast(Channel.class));
26 | assertTrue(output.safeToCast(WritableByteChannel.class));
27 | assertFalse(output.safeToCast(OutputStream.class));
28 | assertFalse(output.safeToCast(ByteArrayOutputStream.class));
29 |
30 | assertNotNull(output.unwrap(WritableByteChannel.class));
31 | }
32 |
33 | @Test
34 | void create_stream_output() {
35 | final var byteArrayOutputStream = new ByteArrayOutputStream();
36 | final var output = PartOutput.from(byteArrayOutputStream);
37 |
38 | assertTrue(output.safeToCast(OutputStream.class));
39 | assertTrue(output.safeToCast(ByteArrayOutputStream.class));
40 | assertFalse(output.safeToCast(Channel.class));
41 | assertFalse(output.safeToCast(WritableByteChannel.class));
42 |
43 | assertNotNull(output.unwrap(OutputStream.class));
44 | }
45 |
46 | @Test
47 | void create_path_output() {
48 | final var path = Paths.get("");
49 | final var output = PartOutput.from(path);
50 |
51 | assertTrue(output.safeToCast(Path.class));
52 |
53 | assertNotNull(output.unwrap(Path.class));
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/UploadParserTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload;
2 |
3 | import static com.github.elopteryx.upload.util.Servlets.newRequest;
4 | import static com.github.elopteryx.upload.util.Servlets.newResponse;
5 | import static org.junit.jupiter.api.Assertions.assertAll;
6 | import static org.junit.jupiter.api.Assertions.assertFalse;
7 | import static org.junit.jupiter.api.Assertions.assertThrows;
8 | import static org.junit.jupiter.api.Assertions.assertTrue;
9 | import static org.mockito.Mockito.mock;
10 | import static org.mockito.Mockito.when;
11 |
12 | import com.github.elopteryx.upload.util.NullChannel;
13 | import com.google.common.jimfs.Jimfs;
14 | import org.junit.jupiter.api.BeforeAll;
15 | import org.junit.jupiter.api.Test;
16 |
17 | import java.nio.ByteBuffer;
18 | import java.nio.file.FileSystem;
19 | import java.nio.file.Files;
20 | import jakarta.servlet.AsyncContext;
21 | import jakarta.servlet.ServletInputStream;
22 | import jakarta.servlet.http.HttpServletResponse;
23 |
24 | class UploadParserTest implements OnPartBegin, OnPartEnd, OnRequestComplete, OnError {
25 |
26 | private static FileSystem fileSystem;
27 |
28 | @BeforeAll
29 | static void setUp() {
30 | fileSystem = Jimfs.newFileSystem();
31 | }
32 |
33 | @Test
34 | void valid_content_type() throws Exception {
35 | final var request = newRequest();
36 |
37 | when(request.getContentType()).thenReturn("multipart/");
38 | assertTrue(UploadParser.isMultipart(request));
39 | }
40 |
41 | @Test
42 | void invalid_numeric_arguments() {
43 | assertAll(
44 | () -> assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().sizeThreshold(-1)),
45 | () -> assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().maxPartSize(-1)),
46 | () -> assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().maxRequestSize(-1)),
47 | () -> assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().maxBytesUsed(-1))
48 | );
49 | }
50 |
51 | @Test
52 | void invalid_content_type_async() throws Exception {
53 | final var request = newRequest();
54 |
55 | when(request.getContentType()).thenReturn("text/plain;charset=UTF-8");
56 | assertFalse(UploadParser.isMultipart(request));
57 | assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().userObject(newResponse()).setupAsyncParse(request));
58 | }
59 |
60 | @Test
61 | void invalid_content_type_blocking() throws Exception {
62 | final var request = newRequest();
63 |
64 | when(request.getContentType()).thenReturn("text/plain;charset=UTF-8");
65 | assertFalse(UploadParser.isMultipart(request));
66 | assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().userObject(newResponse()).doBlockingParse(request));
67 | }
68 |
69 | @Test
70 | void use_the_full_api() throws Exception {
71 | final var request = newRequest();
72 | final var response = newResponse();
73 |
74 | when(request.startAsync()).thenReturn(mock(AsyncContext.class));
75 | when(request.getInputStream()).thenReturn(mock(ServletInputStream.class));
76 |
77 | UploadParser.newParser()
78 | .onPartBegin(this)
79 | .onPartEnd(this)
80 | .onRequestComplete(this)
81 | .onError(this)
82 | .userObject(response)
83 | .maxBytesUsed(4096)
84 | .sizeThreshold(1024 * 1024 * 10)
85 | .maxPartSize(1024 * 1024 * 50)
86 | .maxRequestSize(1024 * 1024 * 50)
87 | .setupAsyncParse(request);
88 | }
89 |
90 | @Test
91 | void output_channel() {
92 | UploadParser.newParser()
93 | .onPartBegin((context, buffer) -> {
94 | final var test = fileSystem.getPath("test1");
95 | Files.createFile(test);
96 | return PartOutput.from(Files.newByteChannel(test));
97 | });
98 | }
99 |
100 | @Test
101 | void output_stream() {
102 | UploadParser.newParser()
103 | .onPartBegin((context, buffer) -> {
104 | final var test = fileSystem.getPath("test2");
105 | Files.createFile(test);
106 | return PartOutput.from(Files.newOutputStream(test));
107 | });
108 | }
109 |
110 | @Test
111 | void output_path() {
112 | UploadParser.newParser()
113 | .onPartBegin((context, buffer) -> {
114 | final var test = fileSystem.getPath("test2");
115 | Files.createFile(test);
116 | return PartOutput.from(test);
117 | });
118 | }
119 |
120 | @Test
121 | void use_with_custom_object() {
122 | UploadParser.newParser()
123 | .userObject(newResponse())
124 | .onPartBegin((context, buffer) -> {
125 | final var test = fileSystem.getPath("test2");
126 | Files.createFile(test);
127 | return PartOutput.from(test);
128 | })
129 | .onRequestComplete(context -> context.getUserObject(HttpServletResponse.class).setStatus(HttpServletResponse.SC_OK));
130 | }
131 |
132 | @Override
133 | public PartOutput onPartBegin(final UploadContext context, final ByteBuffer buffer) {
134 | return PartOutput.from(new NullChannel());
135 | }
136 |
137 | @Override
138 | public void onPartEnd(final UploadContext context) {
139 | // No-op
140 | }
141 |
142 | @Override
143 | public void onRequestComplete(final UploadContext context) {
144 | // No-op
145 | }
146 |
147 | @Override
148 | public void onError(final UploadContext context, final Throwable throwable) {
149 | // No-op
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/AbstractUploadParserTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 | import static org.mockito.Mockito.when;
7 |
8 | import com.github.elopteryx.upload.errors.PartSizeException;
9 | import com.github.elopteryx.upload.errors.RequestSizeException;
10 | import com.github.elopteryx.upload.util.Servlets;
11 | import org.junit.jupiter.api.Test;
12 |
13 | class AbstractUploadParserTest {
14 |
15 | private static final long SIZE = 1024 * 1024 * 100L;
16 | private static final long SMALL_SIZE = 1024;
17 |
18 | private AbstractUploadParser runSetupForSize(final long requestSize, final long allowedRequestSize, final long allowedPartSize) throws Exception {
19 | final var request = Servlets.newRequest();
20 |
21 | when(request.getContentLengthLong()).thenReturn(requestSize);
22 |
23 | final var parser = new AsyncUploadParser(request);
24 | parser.setMaxPartSize(allowedPartSize);
25 | parser.setMaxRequestSize(allowedRequestSize);
26 | parser.setupAsyncParse();
27 | return parser;
28 | }
29 |
30 | @Test
31 | void setup_should_work_if_lesser() throws Exception {
32 | runSetupForSize(SIZE - 1, SIZE, -1);
33 | }
34 |
35 | @Test
36 | void setup_should_work_if_equals() throws Exception {
37 | runSetupForSize(SIZE, SIZE, -1);
38 | }
39 |
40 | @Test
41 | void setup_should_throw_size_exception_if_greater() {
42 | assertThrows(RequestSizeException.class, () -> runSetupForSize(SIZE + 1, SIZE, -1));
43 | }
44 |
45 | @Test
46 | void parser_should_throw_exception_for_request_size() {
47 | final var exception = assertThrows(RequestSizeException.class, () -> {
48 | final var parser = runSetupForSize(0, SMALL_SIZE, -1);
49 | for (var i = 0; i < 11; i++) {
50 | parser.checkRequestSize(100);
51 | }
52 | });
53 | assertEquals(exception.getPermittedSize(), SMALL_SIZE);
54 | assertTrue(exception.getActualSize() > SMALL_SIZE);
55 | }
56 |
57 | @Test
58 | void parser_should_throw_exception_for_part_size() {
59 | final var exception = assertThrows(PartSizeException.class, () -> {
60 | final var parser = runSetupForSize(0, -1, SMALL_SIZE);
61 | for (var i = 0; i < 11; i++) {
62 | parser.checkPartSize(100);
63 | }
64 | });
65 | assertEquals(exception.getPermittedSize(), SMALL_SIZE);
66 | assertTrue(exception.getActualSize() > SMALL_SIZE);
67 | }
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/AsyncUploadParserTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertThrows;
4 | import static org.mockito.Mockito.when;
5 |
6 | import com.github.elopteryx.upload.UploadParser;
7 | import com.github.elopteryx.upload.errors.MultipartException;
8 | import com.github.elopteryx.upload.util.MockServletInputStream;
9 | import com.github.elopteryx.upload.util.Servlets;
10 | import org.junit.jupiter.api.Test;
11 |
12 | class AsyncUploadParserTest {
13 |
14 | @Test
15 | void this_should_end_with_multipart_exception() throws Exception {
16 | final var request = Servlets.newRequest();
17 |
18 | when(request.isAsyncSupported()).thenReturn(true);
19 | when(request.getHeader(Headers.CONTENT_TYPE)).thenReturn("multipart/form-data; boundary=----1234");
20 |
21 | UploadParser.newParser().setupAsyncParse(request);
22 | final var servletInputStream = (MockServletInputStream)request.getInputStream();
23 | assertThrows(MultipartException.class, servletInputStream::onDataAvailable);
24 | }
25 |
26 | @Test
27 | void this_should_end_with_illegal_state_exception() throws Exception {
28 | final var request = Servlets.newRequest();
29 |
30 | when(request.isAsyncSupported()).thenReturn(false);
31 |
32 | assertThrows(IllegalStateException.class, () -> UploadParser.newParser().setupAsyncParse(request));
33 | }
34 |
35 | @Test
36 | void this_should_end_with_illegal_argument_exception() throws Exception {
37 | final var request = Servlets.newRequest();
38 |
39 | when(request.isAsyncSupported()).thenReturn(true);
40 | when(request.getHeader(Headers.CONTENT_TYPE)).thenReturn("multipart/form-data; boundary;");
41 |
42 | assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().setupAsyncParse(request));
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/Base64EncodingTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static java.nio.charset.StandardCharsets.US_ASCII;
4 | import static org.junit.jupiter.api.Assertions.assertEquals;
5 | import static org.junit.jupiter.api.Assertions.assertThrows;
6 |
7 | import org.junit.jupiter.api.Test;
8 |
9 | import java.io.IOException;
10 | import java.nio.ByteBuffer;
11 |
12 | class Base64EncodingTest {
13 |
14 | @Test
15 | void these_values_should_work() throws IOException {
16 | checkEncoding("", "");
17 | checkEncoding("f", "Zg==");
18 | checkEncoding("fo", "Zm8=");
19 | checkEncoding("foo", "Zm9v");
20 | checkEncoding("foob", "Zm9vYg==");
21 | checkEncoding("fooba", "Zm9vYmE=");
22 | checkEncoding("foobar", "Zm9vYmFy");
23 | }
24 |
25 | @Test
26 | void must_throw_exception_on_invalid_data() {
27 | assertThrows(IOException.class, () -> checkEncoding("f", "Zg=�="));
28 | }
29 |
30 | private static void checkEncoding(final String original, final String encoded) throws IOException {
31 |
32 | final var encoding = new MultipartParser.Base64Encoding(1024);
33 | encoding.handle(new MultipartParser.PartHandler() {
34 |
35 | @Override
36 | public void beginPart(final Headers headers) {
37 | // No-op
38 | }
39 |
40 | @Override
41 | public void data(final ByteBuffer buffer) {
42 | final var parserResult = new String(buffer.array(), US_ASCII).trim();
43 | assertEquals(parserResult, original);
44 | }
45 |
46 | @Override
47 | public void endPart() {
48 | // No-op
49 | }
50 |
51 | }, ByteBuffer.wrap(encoded.getBytes(US_ASCII)));
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/BlockingUploadParserTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertFalse;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 | import static org.mockito.Mockito.when;
7 |
8 | import com.github.elopteryx.upload.OnError;
9 | import com.github.elopteryx.upload.OnPartBegin;
10 | import com.github.elopteryx.upload.OnPartEnd;
11 | import com.github.elopteryx.upload.PartOutput;
12 | import com.github.elopteryx.upload.UploadContext;
13 | import com.github.elopteryx.upload.UploadParser;
14 | import com.github.elopteryx.upload.errors.MultipartException;
15 | import com.github.elopteryx.upload.util.Servlets;
16 | import org.junit.jupiter.api.Test;
17 |
18 | import java.io.ByteArrayOutputStream;
19 | import java.nio.ByteBuffer;
20 | import java.util.ArrayList;
21 | import java.util.List;
22 |
23 | class BlockingUploadParserTest implements OnPartBegin, OnPartEnd, OnError {
24 |
25 | private final List strings = new ArrayList<>();
26 |
27 | @Test
28 | void this_should_end_with_multipart_exception() throws Exception {
29 | final var request = Servlets.newRequest();
30 | final var response = Servlets.newResponse();
31 |
32 | when(request.isAsyncSupported()).thenReturn(false);
33 | when(request.getHeader(Headers.CONTENT_TYPE)).thenReturn("multipart/form-data; boundary=----1234");
34 |
35 | UploadParser.newParser()
36 | .onPartBegin(this)
37 | .onPartEnd(this)
38 | .onError(this)
39 | .userObject(response)
40 | .doBlockingParse(request);
41 | }
42 |
43 | @Test
44 | void this_should_end_with_illegal_argument_exception() throws Exception {
45 | final var request = Servlets.newRequest();
46 |
47 | when(request.isAsyncSupported()).thenReturn(false);
48 | when(request.getHeader(Headers.CONTENT_TYPE)).thenReturn("multipart/form-data;");
49 |
50 | assertThrows(IllegalArgumentException.class, () -> UploadParser.newParser().doBlockingParse(request));
51 | }
52 |
53 | @Override
54 | public PartOutput onPartBegin(final UploadContext context, final ByteBuffer buffer) {
55 | final var baos = new ByteArrayOutputStream();
56 | strings.add(baos);
57 | return PartOutput.from(baos);
58 | }
59 |
60 | @Override
61 | public void onPartEnd(final UploadContext context) {
62 | assertFalse(strings.isEmpty());
63 | }
64 |
65 | @Override
66 | public void onError(final UploadContext context, final Throwable throwable) {
67 | assertTrue(throwable instanceof MultipartException);
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/HeadersTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertFalse;
5 | import static org.junit.jupiter.api.Assertions.assertNull;
6 | import static org.junit.jupiter.api.Assertions.assertTrue;
7 |
8 | import org.junit.jupiter.api.Test;
9 |
10 | import java.util.Iterator;
11 | import java.util.Locale;
12 |
13 | class HeadersTest {
14 |
15 | @Test
16 | void add_and_retrieve_headers() {
17 | final var headers = new Headers();
18 | headers.addHeader(Headers.CONTENT_DISPOSITION, "form-data; name=\"FileItem\"; filename=\"file1.txt\"");
19 | headers.addHeader(Headers.CONTENT_TYPE, "text/plain");
20 | headers.addHeader("TestHeader", "headerValue1");
21 | headers.addHeader("TestHeader", "headerValue2");
22 | headers.addHeader("TestHeader", "headerValue3");
23 | headers.addHeader("testheader", "headerValue4");
24 |
25 | final var headerNames = headers.getHeaderNames().iterator();
26 | assertEquals(Headers.CONTENT_DISPOSITION.toLowerCase(Locale.ENGLISH), headerNames.next());
27 | assertEquals(Headers.CONTENT_TYPE.toLowerCase(Locale.ENGLISH), headerNames.next());
28 | assertEquals("testheader", headerNames.next());
29 | assertFalse(headerNames.hasNext());
30 |
31 | assertEquals(headers.getHeader(Headers.CONTENT_DISPOSITION), "form-data; name=\"FileItem\"; filename=\"file1.txt\"");
32 | assertEquals(headers.getHeader(Headers.CONTENT_TYPE), "text/plain");
33 | assertEquals(headers.getHeader(Headers.CONTENT_TYPE), "text/plain");
34 | assertEquals(headers.getHeader("TestHeader"), "headerValue1");
35 | assertNull(headers.getHeader("DummyHeader"));
36 |
37 | Iterator headerValues;
38 |
39 | headerValues = headers.getHeaders("Content-Type").iterator();
40 | assertTrue(headerValues.hasNext());
41 | assertEquals(headerValues.next(), "text/plain");
42 | assertFalse(headerValues.hasNext());
43 |
44 | headerValues = headers.getHeaders("content-type").iterator();
45 | assertTrue(headerValues.hasNext());
46 | assertEquals(headerValues.next(), "text/plain");
47 | assertFalse(headerValues.hasNext());
48 |
49 | headerValues = headers.getHeaders("TestHeader").iterator();
50 | assertTrue(headerValues.hasNext());
51 | assertEquals(headerValues.next(), "headerValue1");
52 | assertTrue(headerValues.hasNext());
53 | assertEquals(headerValues.next(), "headerValue2");
54 | assertTrue(headerValues.hasNext());
55 | assertEquals(headerValues.next(), "headerValue3");
56 | assertTrue(headerValues.hasNext());
57 | assertEquals(headerValues.next(), "headerValue4");
58 | assertFalse(headerValues.hasNext());
59 |
60 | headerValues = headers.getHeaders("DummyHeader").iterator();
61 | assertFalse(headerValues.hasNext());
62 | }
63 |
64 | @Test
65 | void charset_parsing() {
66 | assertNull(Headers.extractQuotedValueFromHeader("text/html; other-data=\"charset=UTF-8\"", "charset"));
67 | assertNull(Headers.extractQuotedValueFromHeader("text/html;", "charset"));
68 | assertEquals("UTF-8", Headers.extractQuotedValueFromHeader("text/html; charset=\"UTF-8\"", "charset"));
69 | assertEquals("UTF-8", Headers.extractQuotedValueFromHeader("text/html; charset=UTF-8", "charset"));
70 | assertEquals("UTF-8", Headers.extractQuotedValueFromHeader("text/html; charset=\"UTF-8\"; foo=bar", "charset"));
71 | assertEquals("UTF-8", Headers.extractQuotedValueFromHeader("text/html; charset=UTF-8 foo=bar", "charset"));
72 | }
73 |
74 | @Test
75 | void extract_existing_boundary() {
76 | assertEquals("--xyz", Headers.extractBoundaryFromHeader("multipart/form-data; boundary=--xyz; param=abc"));
77 | }
78 |
79 | @Test
80 | void extract_missing_boundary() {
81 | assertNull(Headers.extractBoundaryFromHeader("multipart/form-data; boundary;"));
82 | }
83 |
84 | @Test
85 | void extract_param_with_tailing_whitespace() {
86 | assertEquals("abc", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=abc", "param"));
87 | assertEquals("abc", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=abc ", "param"));
88 | assertEquals("", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param= abc", "param"));
89 | assertEquals("", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param= abc ", "param"));
90 |
91 | assertEquals("abc", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=\"abc\"", "param"));
92 | assertEquals("abc ", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=\"abc \"", "param"));
93 | assertEquals(" abc", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=\" abc\"", "param"));
94 | assertEquals(" abc ", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=\" abc \"", "param"));
95 |
96 | assertNull(Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param\t=abc", "param"));
97 | assertEquals("ab", Headers.extractQuotedValueFromHeader("multipart/form-data; boundary=--xyz; param=ab\tc", "param"));
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/IdentityEncodingTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static java.nio.charset.StandardCharsets.UTF_8;
4 | import static org.junit.jupiter.api.Assertions.assertEquals;
5 |
6 | import org.junit.jupiter.api.Test;
7 |
8 | import java.io.IOException;
9 | import java.nio.ByteBuffer;
10 |
11 | class IdentityEncodingTest {
12 |
13 | @Test
14 | void these_values_should_work() throws IOException {
15 | checkEncoding("");
16 | checkEncoding("abc");
17 | checkEncoding("öüóúőűáéí");
18 | }
19 |
20 | private static void checkEncoding(final String original) throws IOException {
21 |
22 | final var encoding = new MultipartParser.IdentityEncoding();
23 | encoding.handle(new MultipartParser.PartHandler() {
24 |
25 | @Override
26 | public void beginPart(final Headers headers) {
27 | // No-op
28 | }
29 |
30 | @Override
31 | public void data(final ByteBuffer buffer) {
32 | final var parserResult = new String(buffer.array(), UTF_8);
33 | assertEquals(parserResult, original);
34 | }
35 |
36 | @Override
37 | public void endPart() {
38 | // No-op
39 | }
40 |
41 | }, ByteBuffer.wrap(original.getBytes(UTF_8)));
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/MultipartParserTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static java.nio.charset.StandardCharsets.ISO_8859_1;
4 | import static java.nio.charset.StandardCharsets.UTF_8;
5 | import static org.junit.jupiter.api.Assertions.assertEquals;
6 | import static org.junit.jupiter.api.Assertions.assertFalse;
7 | import static org.junit.jupiter.api.Assertions.assertThrows;
8 | import static org.junit.jupiter.api.Assertions.assertTrue;
9 |
10 | import io.undertow.util.FileUtils;
11 | import org.junit.jupiter.params.ParameterizedTest;
12 | import org.junit.jupiter.params.provider.MethodSource;
13 |
14 | import java.io.IOException;
15 | import java.nio.ByteBuffer;
16 | import java.util.ArrayList;
17 | import java.util.List;
18 |
19 | class MultipartParserTest {
20 |
21 | private static int[] bufferSizeProvider() {
22 | return new int[]{2, 10, 1024, 4096};
23 | }
24 |
25 | @ParameterizedTest
26 | @MethodSource("bufferSizeProvider")
27 | void mime_decoding_with_preamble(final int bufferSize) throws IOException {
28 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime1.txt"));
29 | final var handler = new MockPartHandler();
30 | final var parser = MultipartParser.beginParse(handler, "unique-boundary-1".getBytes(), bufferSize, ISO_8859_1);
31 |
32 | final var buf = ByteBuffer.wrap(data.getBytes());
33 | parser.parse(buf);
34 | assertTrue(parser.isComplete());
35 | assertEquals(2, handler.parts.size());
36 | assertEquals("Here is some text.", handler.parts.get(0).data.toString());
37 | assertEquals("Here is some more text.", handler.parts.get(1).data.toString());
38 |
39 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
40 | }
41 |
42 |
43 | @ParameterizedTest
44 | @MethodSource("bufferSizeProvider")
45 | void mime_decoding_with_utf8_headers(final int bufferSize) throws IOException {
46 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime-utf8.txt"));
47 | final var handler = new MockPartHandler();
48 | final var parser = MultipartParser.beginParse(handler, "unique-boundary-1".getBytes(), bufferSize, UTF_8);
49 |
50 | final var buf = ByteBuffer.wrap(data.getBytes());
51 | parser.parse(buf);
52 | assertTrue(parser.isComplete());
53 | assertEquals(1, handler.parts.size());
54 | assertEquals("Just some chinese characters I copied from the internet, no idea what it says.", handler.parts.get(0).data.toString());
55 |
56 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
57 | }
58 |
59 | @ParameterizedTest
60 | @MethodSource("bufferSizeProvider")
61 | void mime_decoding_without_preamble(final int bufferSize) throws IOException {
62 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime2.txt"));
63 | final var handler = new MockPartHandler();
64 | final var parser = MultipartParser.beginParse(handler, "unique-boundary-1".getBytes(), bufferSize, ISO_8859_1);
65 |
66 | final var buf = ByteBuffer.wrap(data.getBytes());
67 | parser.parse(buf);
68 | assertTrue(parser.isComplete());
69 | assertEquals(2, handler.parts.size());
70 | assertEquals("Here is some text.", handler.parts.get(0).data.toString());
71 | assertEquals("Here is some more text.", handler.parts.get(1).data.toString());
72 |
73 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
74 | }
75 |
76 | @ParameterizedTest
77 | @MethodSource("bufferSizeProvider")
78 | void base64_mime_decoding(final int bufferSize) throws IOException {
79 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime3.txt"));
80 | final var handler = new MockPartHandler();
81 | final var parser = MultipartParser.beginParse(handler, "unique-boundary-1".getBytes(), bufferSize, ISO_8859_1);
82 |
83 | final var buf = ByteBuffer.wrap(data.getBytes());
84 | parser.parse(buf);
85 | assertTrue(parser.isComplete());
86 | assertEquals(2, handler.parts.size());
87 | assertEquals("This is some base64 text.", handler.parts.get(0).data.toString());
88 | assertEquals("This is some more base64 text.", handler.parts.get(1).data.toString());
89 |
90 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
91 | }
92 |
93 | @ParameterizedTest
94 | @MethodSource("bufferSizeProvider")
95 | void quoted_printable(final int bufferSize) throws IOException {
96 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime4.txt"));
97 | final var handler = new MockPartHandler();
98 | final var parser = MultipartParser.beginParse(handler, "someboundarytext".getBytes(), bufferSize, ISO_8859_1);
99 |
100 | final var buf = ByteBuffer.wrap(data.getBytes());
101 | parser.parse(buf);
102 | assertTrue(parser.isComplete());
103 | assertEquals(1, handler.parts.size());
104 | assertEquals("time=money.", handler.parts.get(0).data.toString());
105 |
106 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
107 | }
108 |
109 | @ParameterizedTest
110 | @MethodSource("bufferSizeProvider")
111 | void mime_decoding_malformed(final int bufferSize) throws IOException {
112 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime5_malformed.txt"));
113 | final var handler = new MockPartHandler();
114 | final var parser = MultipartParser.beginParse(handler, "someboundarytext".getBytes(), bufferSize, ISO_8859_1);
115 |
116 | final var buf = ByteBuffer.wrap(data.getBytes());
117 | parser.parse(buf);
118 | assertFalse(parser.isComplete());
119 | }
120 |
121 | @ParameterizedTest
122 | @MethodSource("bufferSizeProvider")
123 | void base64_mime_decoding_malformed(final int bufferSize) {
124 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime6_malformed.txt"));
125 | final var handler = new MockPartHandler();
126 | final var parser = MultipartParser.beginParse(handler, "unique-boundary-1".getBytes(), bufferSize, ISO_8859_1);
127 |
128 | final var buf = ByteBuffer.wrap(data.getBytes());
129 | assertThrows(IOException.class, () -> parser.parse(buf));
130 | }
131 |
132 | @ParameterizedTest
133 | @MethodSource("bufferSizeProvider")
134 | void quoted_printable_malformed(final int bufferSize) throws IOException {
135 | final var data = fixLineEndings(FileUtils.readFile(MultipartParserTest.class, "mime7_malformed.txt"));
136 | final var handler = new MockPartHandler();
137 | final var parser = MultipartParser.beginParse(handler, "someboundarytext".getBytes(), bufferSize, ISO_8859_1);
138 |
139 | final var buf = ByteBuffer.wrap(data.getBytes());
140 | parser.parse(buf);
141 | assertTrue(parser.isComplete());
142 | assertEquals(1, handler.parts.size());
143 | assertEquals("time\nmoney.", handler.parts.get(0).data.toString());
144 |
145 | assertEquals("text/plain", handler.parts.get(0).map.getHeader(Headers.CONTENT_TYPE));
146 | }
147 |
148 | private static class MockPartHandler implements MultipartParser.PartHandler {
149 |
150 | private final List parts = new ArrayList<>();
151 | private Part current;
152 |
153 | @Override
154 | public void beginPart(final Headers headers) {
155 | current = new Part(headers);
156 | parts.add(current);
157 | }
158 |
159 | @Override
160 | public void data(final ByteBuffer buffer) {
161 | while (buffer.hasRemaining()) {
162 | current.data.append((char) buffer.get());
163 | }
164 | }
165 |
166 | @Override
167 | public void endPart() {
168 |
169 | }
170 | }
171 |
172 | private static class Part {
173 | private final Headers map;
174 | private final StringBuilder data = new StringBuilder();
175 |
176 | private Part(final Headers map) {
177 | this.map = map;
178 | }
179 | }
180 |
181 | private static String fixLineEndings(final String string) {
182 | final var builder = new StringBuilder();
183 | for (var i = 0; i < string.length(); ++i) {
184 | final var character = string.charAt(i);
185 | if (character == '\n') {
186 | if (i == 0 || string.charAt(i - 1) != '\r') {
187 | builder.append("\r\n");
188 | } else {
189 | builder.append('\n');
190 | }
191 | } else if (character == '\r') {
192 | if (i + 1 == string.length() || string.charAt(i + 1) != '\n') {
193 | builder.append("\r\n");
194 | } else {
195 | builder.append('\r');
196 | }
197 | } else {
198 | builder.append(character);
199 | }
200 | }
201 | return builder.toString();
202 | }
203 | }
204 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/PartStreamImplTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertFalse;
5 | import static org.junit.jupiter.api.Assertions.assertThrows;
6 |
7 | import com.github.elopteryx.upload.PartStream;
8 | import org.junit.jupiter.api.Test;
9 |
10 | class PartStreamImplTest {
11 |
12 | @Test
13 | void it_should_return_the_correct_data() {
14 | final var fileName = "r-" + System.currentTimeMillis();
15 | final var fieldName = "r-" + System.currentTimeMillis();
16 | final var contentType = "r-" + System.currentTimeMillis();
17 | final var headers = new Headers();
18 | headers.addHeader(Headers.CONTENT_TYPE, contentType);
19 | final PartStream partStream = new PartStreamImpl(fileName, fieldName, headers);
20 | assertEquals(fileName, partStream.getSubmittedFileName());
21 | assertEquals(fieldName, partStream.getName());
22 | assertEquals(contentType, partStream.getContentType());
23 | assertEquals(partStream.isFile(), partStream.getSubmittedFileName() != null);
24 | assertFalse(partStream.isFinished());
25 | }
26 |
27 | @Test
28 | void invalid_file_names_are_not_allowed() {
29 | final var fileName = "r-" + System.currentTimeMillis() + '\u0000';
30 | final PartStream partStream = new PartStreamImpl(fileName, null, new Headers());
31 | assertThrows(IllegalArgumentException.class, partStream::getSubmittedFileName);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/QuotedPrintableEncodingTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal;
2 |
3 | import static java.nio.charset.StandardCharsets.US_ASCII;
4 | import static org.junit.jupiter.api.Assertions.assertEquals;
5 |
6 | import org.junit.jupiter.api.Test;
7 |
8 | import java.io.IOException;
9 | import java.nio.ByteBuffer;
10 |
11 | class QuotedPrintableEncodingTest {
12 |
13 | @Test
14 | void empty_decode() throws IOException {
15 | checkEncoding("", "");
16 | }
17 |
18 | @Test
19 | void plain_decode() throws IOException {
20 | checkEncoding("A longer sentence without special characters.", "A longer sentence without special characters.");
21 | }
22 |
23 | @Test
24 | void basic_encode_decode() throws IOException {
25 | checkEncoding("= Hello world =\r\n", "=3D Hello world =3D=0D=0A");
26 | }
27 |
28 | @Test
29 | void unsafe_decode() throws IOException {
30 | checkEncoding("=\r\n", "=3D=0D=0A");
31 | }
32 |
33 | @Test
34 | void unsafe_decode_lowercase() throws IOException {
35 | checkEncoding("=\r\n", "=3d=0d=0a");
36 | }
37 |
38 | private static void checkEncoding(final String original, final String encoded) throws IOException {
39 | final var encoding = new MultipartParser.QuotedPrintableEncoding(1024);
40 | encoding.handle(new MultipartParser.PartHandler() {
41 |
42 | @Override
43 | public void beginPart(final Headers headers) {
44 | // No-op
45 | }
46 |
47 | @Override
48 | public void data(final ByteBuffer buffer) {
49 | final var parserResult = new String(buffer.array(), US_ASCII).trim();
50 | assertEquals(parserResult, original.trim());
51 | }
52 |
53 | @Override
54 | public void endPart() {
55 | // No-op
56 | }
57 |
58 | }, ByteBuffer.wrap(encoded.getBytes(US_ASCII)));
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/AsyncUploadServlet.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static java.nio.charset.StandardCharsets.ISO_8859_1;
4 | import static java.nio.file.StandardOpenOption.CREATE;
5 | import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;
6 | import static java.nio.file.StandardOpenOption.WRITE;
7 | import static org.junit.jupiter.api.Assertions.assertArrayEquals;
8 | import static org.junit.jupiter.api.Assertions.assertEquals;
9 | import static org.junit.jupiter.api.Assertions.assertFalse;
10 | import static org.junit.jupiter.api.Assertions.assertTrue;
11 | import static org.junit.jupiter.api.Assertions.fail;
12 |
13 | import com.github.elopteryx.upload.OnRequestComplete;
14 | import com.github.elopteryx.upload.PartOutput;
15 | import com.github.elopteryx.upload.UploadParser;
16 | import com.github.elopteryx.upload.util.ByteBufferBackedInputStream;
17 | import com.github.elopteryx.upload.util.NullChannel;
18 |
19 | import java.io.ByteArrayOutputStream;
20 | import java.io.IOException;
21 | import java.nio.channels.Channel;
22 | import java.nio.file.Files;
23 | import java.util.*;
24 | import java.util.concurrent.atomic.AtomicInteger;
25 | import jakarta.servlet.ServletException;
26 | import jakarta.servlet.annotation.WebServlet;
27 | import jakarta.servlet.http.HttpServlet;
28 | import jakarta.servlet.http.HttpServletRequest;
29 | import jakarta.servlet.http.HttpServletResponse;
30 |
31 | @WebServlet(value = "/async", asyncSupported = true)
32 | public class AsyncUploadServlet extends HttpServlet {
33 |
34 | @Override
35 | @SuppressWarnings("PMD.SwitchStmtsShouldHaveDefault")
36 | protected void doPost(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
37 | final var query = request.getQueryString();
38 | switch (query) {
39 | case ClientRequest.SIMPLE -> simple(request, response);
40 | case ClientRequest.THRESHOLD_LESSER -> thresholdLesser(request, response);
41 | case ClientRequest.THRESHOLD_GREATER -> thresholdGreater(request, response);
42 | case ClientRequest.ERROR -> error(request, response);
43 | case ClientRequest.IO_ERROR_UPON_ERROR -> ioErrorUponError(request);
44 | case ClientRequest.SERVLET_ERROR_UPON_ERROR -> servletErrorUponError(request);
45 | case ClientRequest.COMPLEX -> complex(request, response);
46 | }
47 | }
48 |
49 | private void simple(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
50 | UploadParser.newParser()
51 | .onPartBegin((context, buffer) -> {
52 | if (context.getPartStreams().size() == 1) {
53 | final var dir = ClientRequest.FILE_SYSTEM.getPath("");
54 | final var temp = dir.resolve(context.getCurrentPart().getSubmittedFileName());
55 | return PartOutput.from(Files.newByteChannel(temp, EnumSet.of(CREATE, TRUNCATE_EXISTING, WRITE)));
56 | } else if (context.getPartStreams().size() == 2) {
57 | final var dir = ClientRequest.FILE_SYSTEM.getPath("");
58 | final var temp = dir.resolve(context.getCurrentPart().getSubmittedFileName());
59 | return PartOutput.from(Files.newOutputStream(temp));
60 | } else if (context.getPartStreams().size() == 3) {
61 | final var dir = ClientRequest.FILE_SYSTEM.getPath("");
62 | final var temp = dir.resolve(context.getCurrentPart().getSubmittedFileName());
63 | return PartOutput.from(temp);
64 | } else {
65 | return PartOutput.from(new NullChannel());
66 | }
67 | })
68 | .onPartEnd(context -> {
69 | if (context.getCurrentOutput() != null && context.getCurrentOutput().safeToCast(Channel.class)) {
70 | final var channel = context.getCurrentOutput().unwrap(Channel.class);
71 | if (channel.isOpen()) {
72 | fail("The parser should close it!");
73 | }
74 | }
75 | })
76 | .onRequestComplete(context -> {
77 | request.getAsyncContext().complete();
78 | response.setStatus(200);
79 | })
80 | .setupAsyncParse(request);
81 | }
82 |
83 | private static class EvilOutput extends PartOutput {
84 | EvilOutput(final Object value) {
85 | super(value);
86 | }
87 | }
88 |
89 | private void thresholdLesser(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
90 |
91 | UploadParser.newParser()
92 | .onPartBegin((context, buffer) -> {
93 | final var currentPart = context.getCurrentPart();
94 | assertTrue(currentPart.isFinished());
95 | return PartOutput.from(new NullChannel());
96 | })
97 | .onRequestComplete(onSuccessfulFinish(request, response, 512))
98 | .sizeThreshold(1024)
99 | .setupAsyncParse(request);
100 | }
101 |
102 | private void thresholdGreater(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
103 |
104 | UploadParser.newParser()
105 | .onPartBegin((context, buffer) -> {
106 | final var currentPart = context.getCurrentPart();
107 | assertFalse(currentPart.isFinished());
108 | return PartOutput.from(new NullChannel());
109 | })
110 | .onRequestComplete(onSuccessfulFinish(request, response, 2048))
111 | .sizeThreshold(1024)
112 | .setupAsyncParse(request);
113 | }
114 |
115 | private void error(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
116 |
117 | UploadParser.newParser()
118 | .onPartBegin((context, buffer) -> new EvilOutput("This will cause an error!"))
119 | .onError((context, throwable) -> response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR))
120 | .setupAsyncParse(request);
121 | }
122 |
123 | private void ioErrorUponError(final HttpServletRequest request) throws ServletException, IOException {
124 | request.startAsync().setTimeout(500);
125 | UploadParser.newParser()
126 | .onRequestComplete(context -> {
127 | throw new IOException();
128 | })
129 | .onError((context, throwable) -> {
130 | throw new ServletException();
131 | })
132 | .setupAsyncParse(request);
133 | }
134 |
135 | private void servletErrorUponError(final HttpServletRequest request) throws ServletException, IOException {
136 | request.startAsync().setTimeout(500);
137 | // onError will not be called for ServletException!
138 | UploadParser.newParser()
139 | .onRequestComplete(context -> {
140 | throw new ServletException();
141 | })
142 | .setupAsyncParse(request);
143 | }
144 |
145 | private void complex(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
146 |
147 | if (!UploadParser.isMultipart(request)) {
148 | throw new ServletException("Not multipart!");
149 | }
150 |
151 | final var partCounter = new AtomicInteger(0);
152 | final List formFields = new ArrayList<>();
153 |
154 | final var expectedContentTypes = Arrays.asList(
155 | "text/plain",
156 | "text/plain",
157 | "text/plain",
158 | "text/plain",
159 | "text/plain",
160 | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
161 | "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
162 | "image/jpeg");
163 |
164 | UploadParser.newParser()
165 | .onPartBegin((context, buffer) -> {
166 | final var part = context.getCurrentPart();
167 |
168 | final var detectedType = ClientRequest.TIKA.detect(new ByteBufferBackedInputStream(buffer), part.getSubmittedFileName());
169 | final var expectedType = expectedContentTypes.get(partCounter.getAndIncrement());
170 | if ("text/plain".equals(expectedType)) {
171 | assertTrue("text/plain".equals(detectedType) || "application/octet-stream".equals(detectedType));
172 | } else {
173 | assertEquals(detectedType, expectedType);
174 | }
175 | assertEquals(part.getHeaderNames(), Set.of("content-disposition", "content-type"));
176 | if (part.isFile()) {
177 | if ("".equals(part.getSubmittedFileName())) {
178 | throw new IOException("No file was chosen for the form field!");
179 | }
180 | assertFalse(part.getHeaders("content-type").isEmpty());
181 | assertEquals(part.getContentType(), part.getHeader("content-type"));
182 | final var baos = new ByteArrayOutputStream();
183 | formFields.add(baos);
184 | return PartOutput.from(baos);
185 | } else {
186 | final var baos = new ByteArrayOutputStream();
187 | formFields.add(baos);
188 | return PartOutput.from(baos);
189 | }
190 | })
191 | .onPartEnd(context -> {})
192 | .onRequestComplete(context -> {
193 | assertArrayEquals(formFields.get(0).toByteArray(), RequestSupplier.LARGE_FILE);
194 | assertArrayEquals(formFields.get(1).toByteArray(), RequestSupplier.EMPTY_FILE);
195 | assertArrayEquals(formFields.get(2).toByteArray(), RequestSupplier.SMALL_FILE);
196 | assertArrayEquals(formFields.get(3).toByteArray(), RequestSupplier.TEXT_VALUE_1.getBytes(ISO_8859_1));
197 | assertArrayEquals(formFields.get(4).toByteArray(), RequestSupplier.TEXT_VALUE_2.getBytes(ISO_8859_1));
198 |
199 | context.getUserObject(HttpServletResponse.class).setStatus(HttpServletResponse.SC_OK);
200 | context.getRequest().getAsyncContext().complete();
201 | })
202 | .onError((context, throwable) -> response.sendError(500))
203 | .userObject(response)
204 | .sizeThreshold(4096)
205 | .maxPartSize(Long.MAX_VALUE)
206 | .maxRequestSize(Long.MAX_VALUE)
207 | .setupAsyncParse(request);
208 | }
209 |
210 | private static OnRequestComplete onSuccessfulFinish(final HttpServletRequest request, final HttpServletResponse response, final int size) {
211 | return context -> {
212 | final var currentPart = context.getCurrentPart();
213 | assertTrue(currentPart.isFinished());
214 | assertEquals(size, currentPart.getKnownSize());
215 | assertTrue(request.isAsyncStarted());
216 | request.getAsyncContext().complete();
217 | response.setStatus(200);
218 | };
219 | }
220 | }
221 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/BlockingUploadServlet.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertFalse;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 | import static org.junit.jupiter.api.Assertions.fail;
7 |
8 | import com.github.elopteryx.upload.OnRequestComplete;
9 | import com.github.elopteryx.upload.PartOutput;
10 | import com.github.elopteryx.upload.UploadParser;
11 | import com.github.elopteryx.upload.util.NullChannel;
12 |
13 | import java.io.IOException;
14 | import java.nio.channels.Channel;
15 | import jakarta.servlet.ServletException;
16 | import jakarta.servlet.annotation.WebServlet;
17 | import jakarta.servlet.http.HttpServlet;
18 | import jakarta.servlet.http.HttpServletRequest;
19 | import jakarta.servlet.http.HttpServletResponse;
20 |
21 | @WebServlet("/blocking")
22 | public class BlockingUploadServlet extends HttpServlet {
23 |
24 | @Override
25 | @SuppressWarnings("PMD.SwitchStmtsShouldHaveDefault")
26 | protected void doPost(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
27 | final var query = request.getQueryString();
28 | switch (query) {
29 | case ClientRequest.SIMPLE -> simple(request, response);
30 | case ClientRequest.THRESHOLD_LESSER -> thresholdLesser(request, response);
31 | case ClientRequest.THRESHOLD_GREATER -> thresholdGreater(request, response);
32 | case ClientRequest.ERROR -> error(request, response);
33 | }
34 | }
35 |
36 | private void simple(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
37 | final var context = UploadParser.newParser()
38 | .onPartEnd(context1 -> {
39 | if (context1.getCurrentOutput() != null && context1.getCurrentOutput().safeToCast(Channel.class)) {
40 | final var channel = context1.getCurrentOutput().unwrap(Channel.class);
41 | if (channel.isOpen()) {
42 | fail("The parser should close it!");
43 | }
44 | }
45 | })
46 | .onRequestComplete(context1 -> response.setStatus(200))
47 | .doBlockingParse(request);
48 | assertEquals(8, context.getPartStreams().size());
49 | }
50 |
51 | private void thresholdLesser(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
52 |
53 | UploadParser.newParser()
54 | .onPartBegin((context, buffer) -> {
55 | final var currentPart = context.getCurrentPart();
56 | assertTrue(currentPart.isFinished());
57 | return PartOutput.from(new NullChannel());
58 | })
59 | .onRequestComplete(onSuccessfulFinish(request, response, 512))
60 | .sizeThreshold(1024)
61 | .doBlockingParse(request);
62 | }
63 |
64 | private void thresholdGreater(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
65 |
66 | UploadParser.newParser()
67 | .onPartBegin((context, buffer) -> {
68 | final var currentPart = context.getCurrentPart();
69 | assertFalse(currentPart.isFinished());
70 | return PartOutput.from(new NullChannel());
71 | })
72 | .onRequestComplete(onSuccessfulFinish(request, response, 2048))
73 | .sizeThreshold(1024)
74 | .doBlockingParse(request);
75 | }
76 |
77 | private void error(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException {
78 |
79 | UploadParser.newParser()
80 | .onError((context, throwable) -> response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR))
81 | .maxRequestSize(4096)
82 | .doBlockingParse(request);
83 | }
84 |
85 | private static OnRequestComplete onSuccessfulFinish(final HttpServletRequest request, final HttpServletResponse response, final int size) {
86 | return context -> {
87 | final var currentPart = context.getCurrentPart();
88 | assertTrue(currentPart.isFinished());
89 | assertEquals(size, currentPart.getKnownSize());
90 | assertFalse(request.isAsyncStarted());
91 | response.setStatus(200);
92 | };
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/ClientRequest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withSeveralFields;
4 | import static java.net.http.HttpClient.Version.HTTP_1_1;
5 | import static org.junit.jupiter.api.Assertions.assertEquals;
6 |
7 | import com.google.common.jimfs.Jimfs;
8 | import org.apache.tika.Tika;
9 |
10 | import java.io.IOException;
11 | import java.net.URI;
12 | import java.net.http.HttpClient;
13 | import java.net.http.HttpRequest;
14 | import java.net.http.HttpResponse;
15 | import java.nio.ByteBuffer;
16 | import java.nio.charset.StandardCharsets;
17 | import java.nio.file.FileSystem;
18 | import java.time.Duration;
19 |
20 | /**
21 | * Utility class for making multipart requests.
22 | */
23 | public final class ClientRequest {
24 |
25 | static final String BOUNDARY = "--TNoK9riv6EjfMhxBzj22SKGnOaIhZlxhar";
26 |
27 | static final String SIMPLE = "simple";
28 | static final String THRESHOLD_LESSER = "threshold_lesser";
29 | static final String THRESHOLD_GREATER = "threshold_greater";
30 | static final String ERROR = "error";
31 | static final String IO_ERROR_UPON_ERROR = "io_error_upon_error";
32 | static final String SERVLET_ERROR_UPON_ERROR = "servlet_error_upon_error";
33 | static final String COMPLEX = "complex";
34 |
35 | static final FileSystem FILE_SYSTEM = Jimfs.newFileSystem();
36 |
37 | static final Tika TIKA = new Tika();
38 |
39 | /**
40 | * Creates and sends a randomized multipart request for the
41 | * given address.
42 | * @param url The target address
43 | * @param expectedStatus The expected HTTP response, can be null
44 | * @throws IOException If an IO error occurred
45 | */
46 | public static void performRequest(final String url, final Integer expectedStatus) throws IOException {
47 | performRequest(url, expectedStatus, withSeveralFields());
48 | }
49 |
50 | /**
51 | * Creates and sends a randomized multipart request for the
52 | * given address.
53 | * @param url The target address
54 | * @param expectedStatus The expected HTTP response, can be null
55 | * @param requestData The multipart body, can't be null
56 | * @throws IOException If an IO error occurred
57 | */
58 | public static void performRequest(final String url, final Integer expectedStatus, final ByteBuffer requestData) throws IOException {
59 | final var client = HttpClient.newBuilder().version(HTTP_1_1).build();
60 | final var request = HttpRequest.newBuilder()
61 | .uri(URI.create(url))
62 | .timeout(Duration.ofSeconds(5))
63 | .header("Content-Type", "multipart/form-data; boundary=" + BOUNDARY)
64 | .POST(HttpRequest.BodyPublishers.ofByteArray(requestData.array(), 0, requestData.limit()))
65 | .build();
66 | try {
67 | client.send(request, responseInfo -> {
68 | final var statusCode = responseInfo.statusCode();
69 | if (expectedStatus != null) {
70 | assertEquals((int) expectedStatus, statusCode);
71 | }
72 | return HttpResponse.BodySubscribers.ofString(StandardCharsets.UTF_8);
73 | });
74 | } catch (final InterruptedException e) {
75 | throw new RuntimeException(e);
76 | }
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/JettyIntegrationTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneLargerPicture;
4 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneSmallerPicture;
5 | import static org.junit.jupiter.api.Assertions.fail;
6 |
7 | import org.eclipse.jetty.server.Server;
8 | import org.eclipse.jetty.servlet.ServletHandler;
9 | import org.junit.jupiter.api.AfterAll;
10 | import org.junit.jupiter.api.BeforeAll;
11 | import org.junit.jupiter.api.Test;
12 |
13 | import java.io.IOException;
14 | import java.nio.ByteBuffer;
15 | import jakarta.servlet.http.HttpServletResponse;
16 |
17 | class JettyIntegrationTest {
18 |
19 | private static Server server;
20 |
21 | /**
22 | * Sets up the test environment, generates data to upload, starts a
23 | * Jetty instance which will receive the client requests.
24 | * @throws Exception If an error occurred with the servlets
25 | */
26 | @BeforeAll
27 | static void setUpClass() throws Exception {
28 | server = new Server(8090);
29 |
30 | final var handler = new ServletHandler();
31 | server.setHandler(handler);
32 |
33 | handler.addServletWithMapping(AsyncUploadServlet.class, "/async");
34 | handler.addServletWithMapping(BlockingUploadServlet.class, "/blocking");
35 |
36 | server.start();
37 | }
38 |
39 | @Test
40 | void test_with_a_real_request_simple_async() {
41 | performRequest("http://localhost:8090/async?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
42 | }
43 |
44 | @Test
45 | void test_with_a_real_request_simple_blocking() {
46 | performRequest("http://localhost:8090/blocking?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
47 | }
48 |
49 | @Test
50 | void test_with_a_real_request_threshold_lesser_async() {
51 | performRequest("http://localhost:8090/async?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
52 | }
53 |
54 | @Test
55 | void test_with_a_real_request_threshold_lesser_blocking() {
56 | performRequest("http://localhost:8090/blocking?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
57 | }
58 |
59 | @Test
60 | void test_with_a_real_request_threshold_greater_async() {
61 | performRequest("http://localhost:8090/async?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
62 | }
63 |
64 | @Test
65 | void test_with_a_real_request_threshold_greater_blocking() {
66 | performRequest("http://localhost:8090/blocking?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
67 | }
68 |
69 | @Test
70 | void test_with_a_real_request_error_async() {
71 | performRequest("http://localhost:8090/async?" + ClientRequest.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
72 | }
73 |
74 | @Test
75 | void test_with_a_real_request_io_error_upon_error_async() {
76 | performRequest("http://localhost:8090/async?" + ClientRequest.IO_ERROR_UPON_ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
77 | }
78 |
79 | @Test
80 | void test_with_a_real_request_servlet_error_upon_error_async() {
81 | performRequest("http://localhost:8090/async?" + ClientRequest.SERVLET_ERROR_UPON_ERROR, null);
82 | }
83 |
84 | @Test
85 | void test_with_a_real_request_error_blocking() {
86 | performRequest("http://localhost:8090/blocking?" + ClientRequest.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
87 | }
88 |
89 | @Test
90 | void test_with_a_real_request_complex() {
91 | performRequest("http://localhost:8090/async?" + ClientRequest.COMPLEX, HttpServletResponse.SC_OK);
92 | }
93 |
94 | private void performRequest(final String url, final Integer expectedStatus) {
95 | try {
96 | ClientRequest.performRequest(url, expectedStatus);
97 | } catch (final IOException e) {
98 | if (expectedStatus != null) {
99 | fail("Status returned: " + expectedStatus);
100 | }
101 | }
102 | }
103 |
104 | private void performRequest(final String url, final Integer expectedStatus, final ByteBuffer requestData) {
105 | try {
106 | ClientRequest.performRequest(url, expectedStatus, requestData);
107 | } catch (final IOException e) {
108 | if (expectedStatus != null) {
109 | fail("Status returned: " + expectedStatus);
110 | }
111 | }
112 | }
113 |
114 | @AfterAll
115 | static void tearDown() throws Exception {
116 | server.stop();
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/RequestBuilder.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static java.nio.charset.StandardCharsets.ISO_8859_1;
4 |
5 | import java.nio.ByteBuffer;
6 |
7 | final class RequestBuilder {
8 |
9 | private static final byte[] LINE_FEED = "\r\n".getBytes(ISO_8859_1);
10 |
11 | private final ByteBuffer buffer;
12 |
13 | private final String boundary;
14 |
15 | static RequestBuilder newBuilder(final String boundary) {
16 | return new RequestBuilder(boundary);
17 | }
18 |
19 | private RequestBuilder(final String boundary) {
20 | this.buffer = ByteBuffer.allocate(300_000);
21 | this.boundary = boundary;
22 | }
23 |
24 | RequestBuilder addFormField(final String name, final String value) {
25 | buffer.put(LINE_FEED);
26 | buffer.put(("--" + boundary).getBytes(ISO_8859_1));
27 | buffer.put(LINE_FEED);
28 | buffer.put(("Content-Disposition: form-data; name=\"" + name + "\"").getBytes(ISO_8859_1));
29 | buffer.put(LINE_FEED);
30 | buffer.put(("Content-Type: text/plain; charset=" + ISO_8859_1.name()).getBytes(ISO_8859_1));
31 | buffer.put(LINE_FEED);
32 | buffer.put(LINE_FEED);
33 | buffer.put(value.getBytes(ISO_8859_1));
34 |
35 | return this;
36 | }
37 |
38 | RequestBuilder addFilePart(final String fieldName, final byte[] content, final String contentType, final String fileName) {
39 | buffer.put(LINE_FEED);
40 | buffer.put(("--" + boundary).getBytes(ISO_8859_1));
41 | buffer.put(LINE_FEED);
42 | buffer.put(("Content-Disposition: form-data; name=\"" + fieldName + "\"; filename=\"" + fileName + "\"").getBytes(ISO_8859_1));
43 | buffer.put(LINE_FEED);
44 | buffer.put(("Content-Type: " + contentType).getBytes(ISO_8859_1));
45 | buffer.put(LINE_FEED);
46 | buffer.put(LINE_FEED);
47 | buffer.put(content);
48 |
49 | return this;
50 | }
51 |
52 | ByteBuffer finish() {
53 | buffer.put(LINE_FEED);
54 | buffer.put(("--" + boundary + "--").getBytes(ISO_8859_1));
55 | buffer.put(LINE_FEED);
56 |
57 | buffer.flip();
58 | return buffer;
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/RequestSupplier.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static com.github.elopteryx.upload.internal.integration.ClientRequest.BOUNDARY;
4 | import static java.nio.charset.StandardCharsets.UTF_8;
5 |
6 | import java.io.IOException;
7 | import java.net.URISyntaxException;
8 | import java.nio.ByteBuffer;
9 | import java.nio.file.Files;
10 | import java.nio.file.Paths;
11 | import java.util.Random;
12 |
13 | /**
14 | * Utility class which is responsible for the request body creation.
15 | */
16 | final class RequestSupplier {
17 |
18 | static final byte[] EMPTY_FILE;
19 | static final byte[] SMALL_FILE;
20 | static final byte[] LARGE_FILE;
21 |
22 | static final String TEXT_VALUE_1 = "íéáűúőóüö";
23 | static final String TEXT_VALUE_2 = "abcdef";
24 |
25 | static {
26 | EMPTY_FILE = new byte[0];
27 | SMALL_FILE = "0123456789".getBytes(UTF_8);
28 | final var random = new Random();
29 | final var builder = new StringBuilder();
30 | for (var i = 0; i < 100_000; i++) {
31 | builder.append(random.nextInt(100));
32 | }
33 | LARGE_FILE = builder.toString().getBytes(UTF_8);
34 | }
35 |
36 | static ByteBuffer withSeveralFields() {
37 | return RequestBuilder.newBuilder(BOUNDARY)
38 | .addFilePart("filefield1", LARGE_FILE, "application/octet-stream", "file1.txt")
39 | .addFilePart("filefield2", EMPTY_FILE, "text/plain", "file2.txt")
40 | .addFilePart("filefield3", SMALL_FILE, "application/octet-stream", "file3.txt")
41 | .addFormField("textfield1", TEXT_VALUE_1)
42 | .addFormField("textfield2", TEXT_VALUE_2)
43 | .addFilePart("filefield4", getContents("test.xlsx"), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "test.xlsx")
44 | .addFilePart("filefield5", getContents("test.docx"), "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "test.docx")
45 | .addFilePart("filefield6", getContents("test.jpg"), "image/jpeg", "test.jpg")
46 | .finish();
47 | }
48 |
49 | static ByteBuffer withOneSmallerPicture() {
50 | return RequestBuilder.newBuilder(BOUNDARY)
51 | .addFilePart("filefield", new byte[512], "image/jpeg", "test.jpg")
52 | .finish();
53 | }
54 |
55 | static ByteBuffer withOneLargerPicture() {
56 | return RequestBuilder.newBuilder(BOUNDARY)
57 | .addFilePart("filefield", new byte[2048], "image/jpeg", "test.jpg")
58 | .finish();
59 | }
60 |
61 | private static byte[] getContents(final String resource) {
62 | try {
63 | final var path = Paths.get(ClientRequest.class.getResource(resource).toURI());
64 | return Files.readAllBytes(path);
65 | } catch (final URISyntaxException | IOException e) {
66 | throw new RuntimeException(e);
67 | }
68 | }
69 |
70 | }
71 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/TomcatIntegrationTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneLargerPicture;
4 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneSmallerPicture;
5 | import static org.junit.jupiter.api.Assertions.fail;
6 |
7 | import org.apache.catalina.WebResourceRoot;
8 | import org.apache.catalina.core.StandardContext;
9 | import org.apache.catalina.startup.Tomcat;
10 | import org.apache.catalina.webresources.DirResourceSet;
11 | import org.apache.catalina.webresources.StandardRoot;
12 | import org.junit.jupiter.api.AfterAll;
13 | import org.junit.jupiter.api.BeforeAll;
14 | import org.junit.jupiter.api.Test;
15 |
16 | import java.io.IOException;
17 | import java.nio.ByteBuffer;
18 | import java.nio.file.Files;
19 | import java.nio.file.Paths;
20 | import jakarta.servlet.http.HttpServletResponse;
21 |
22 | class TomcatIntegrationTest {
23 |
24 | private static Tomcat server;
25 |
26 | /**
27 | * Sets up the test environment, generates data to upload, starts a
28 | * Tomcat instance which will receive the client requests.
29 | * @throws Exception If an error occurred with the servlets
30 | */
31 | @BeforeAll
32 | static void setUpClass() throws Exception {
33 | server = new Tomcat();
34 |
35 | final var base = Paths.get("build/tomcat");
36 | Files.createDirectories(base);
37 |
38 | server.setPort(8100);
39 | server.setBaseDir("build/tomcat");
40 | server.getHost().setAppBase("build/tomcat");
41 | server.getHost().setAutoDeploy(true);
42 | server.getHost().setDeployOnStartup(true);
43 |
44 | final var context = (StandardContext) server.addWebapp("", base.toAbsolutePath().toString());
45 |
46 | final var additionWebInfClasses = Paths.get("build/classes");
47 | final WebResourceRoot resources = new StandardRoot(context);
48 | resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes",
49 | additionWebInfClasses.toAbsolutePath().toString(), "/"));
50 | context.setResources(resources);
51 | context.getJarScanner().setJarScanFilter((jarScanType, jarName) -> false);
52 |
53 | server.getConnector();
54 | server.start();
55 | }
56 |
57 | @Test
58 | void test_with_a_real_request_simple_async() {
59 | performRequest("http://localhost:8100/async?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
60 | }
61 |
62 | @Test
63 | void test_with_a_real_request_simple_blocking() {
64 | performRequest("http://localhost:8100/blocking?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
65 | }
66 |
67 | @Test
68 | void test_with_a_real_request_threshold_lesser_async() {
69 | performRequest("http://localhost:8100/async?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
70 | }
71 |
72 | @Test
73 | void test_with_a_real_request_threshold_lesser_blocking() {
74 | performRequest("http://localhost:8100/blocking?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
75 | }
76 |
77 | @Test
78 | void test_with_a_real_request_threshold_greater_async() {
79 | performRequest("http://localhost:8100/async?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
80 | }
81 |
82 | @Test
83 | void test_with_a_real_request_threshold_greater_blocking() {
84 | performRequest("http://localhost:8100/blocking?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
85 | }
86 |
87 | @Test
88 | void test_with_a_real_request_error_async() {
89 | performRequest("http://localhost:8100/async?" + ClientRequest.ERROR, null);
90 | }
91 |
92 | @Test
93 | void test_with_a_real_request_io_error_upon_error_async() {
94 | performRequest("http://localhost:8100/async?" + ClientRequest.IO_ERROR_UPON_ERROR, null);
95 | }
96 |
97 | @Test
98 | void test_with_a_real_request_servlet_error_upon_error_async() {
99 | performRequest("http://localhost:8100/async?" + ClientRequest.SERVLET_ERROR_UPON_ERROR, null);
100 | }
101 |
102 | @Test
103 | void test_with_a_real_request_error_blocking() {
104 | performRequest("http://localhost:8100/blocking?" + ClientRequest.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
105 | }
106 |
107 | @Test
108 | void test_with_a_real_request_complex() {
109 | performRequest("http://localhost:8100/async?" + ClientRequest.COMPLEX, HttpServletResponse.SC_OK);
110 | }
111 |
112 | private void performRequest(final String url, final Integer expectedStatus) {
113 | try {
114 | ClientRequest.performRequest(url, expectedStatus);
115 | } catch (final IOException e) {
116 | if (expectedStatus != null) {
117 | fail("Status returned: " + expectedStatus);
118 | }
119 | }
120 | }
121 |
122 | private void performRequest(final String url, final Integer expectedStatus, final ByteBuffer requestData) {
123 | try {
124 | ClientRequest.performRequest(url, expectedStatus, requestData);
125 | } catch (final IOException e) {
126 | if (expectedStatus != null) {
127 | fail("Status returned: " + expectedStatus);
128 | }
129 | }
130 | }
131 |
132 | @AfterAll
133 | static void tearDown() throws Exception {
134 | server.stop();
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/internal/integration/UndertowIntegrationTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.internal.integration;
2 |
3 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneLargerPicture;
4 | import static com.github.elopteryx.upload.internal.integration.RequestSupplier.withOneSmallerPicture;
5 |
6 | import io.undertow.Handlers;
7 | import io.undertow.Undertow;
8 | import io.undertow.servlet.Servlets;
9 | import org.junit.jupiter.api.AfterAll;
10 | import org.junit.jupiter.api.BeforeAll;
11 | import org.junit.jupiter.api.Test;
12 |
13 | import java.io.IOException;
14 | import java.nio.ByteBuffer;
15 | import jakarta.servlet.http.HttpServletResponse;
16 |
17 | class UndertowIntegrationTest {
18 |
19 | private static Undertow server;
20 |
21 | /**
22 | * Sets up the test environment, generates data to upload, starts an
23 | * Undertow instance which will receive the client requests.
24 | * @throws Exception If an error occurred with the servlets
25 | */
26 | @BeforeAll
27 | static void setUpClass() throws Exception {
28 | final var servletBuilder = Servlets.deployment()
29 | .setClassLoader(Thread.currentThread().getContextClassLoader())
30 | .setContextPath("/")
31 | .setDeploymentName("ROOT.war")
32 | .addServlets(
33 | Servlets.servlet("AsyncUploadServlet", AsyncUploadServlet.class)
34 | .addMapping("/async")
35 | .setAsyncSupported(true),
36 | Servlets.servlet("BlockingUploadServlet", BlockingUploadServlet.class)
37 | .addMapping("/blocking")
38 | .setAsyncSupported(false)
39 | );
40 |
41 | final var manager = Servlets.defaultContainer().addDeployment(servletBuilder);
42 | manager.deploy();
43 | final var path = Handlers.path(Handlers.redirect("/")).addPrefixPath("/", manager.start());
44 |
45 | server = Undertow.builder()
46 | .addHttpListener(8080, "localhost")
47 | .setHandler(path)
48 | .build();
49 | server.start();
50 | }
51 |
52 | @Test
53 | void test_with_a_real_request_simple_async() throws IOException {
54 | performRequest("http://localhost:8080/async?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
55 | }
56 |
57 | @Test
58 | void test_with_a_real_request_simple_blocking() throws IOException {
59 | performRequest("http://localhost:8080/blocking?" + ClientRequest.SIMPLE, HttpServletResponse.SC_OK);
60 | }
61 |
62 | @Test
63 | void test_with_a_real_request_threshold_lesser_async() throws IOException {
64 | performRequest("http://localhost:8080/async?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
65 | }
66 |
67 | @Test
68 | void test_with_a_real_request_threshold_lesser_blocking() throws IOException {
69 | performRequest("http://localhost:8080/blocking?" + ClientRequest.THRESHOLD_LESSER, HttpServletResponse.SC_OK, withOneSmallerPicture());
70 | }
71 |
72 | @Test
73 | void test_with_a_real_request_threshold_greater_async() throws IOException {
74 | performRequest("http://localhost:8080/async?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
75 | }
76 |
77 | @Test
78 | void test_with_a_real_request_threshold_greater_blocking() throws IOException {
79 | performRequest("http://localhost:8080/blocking?" + ClientRequest.THRESHOLD_GREATER, HttpServletResponse.SC_OK, withOneLargerPicture());
80 | }
81 |
82 | @Test
83 | void test_with_a_real_request_error_async() throws IOException {
84 | performRequest("http://localhost:8080/async?" + ClientRequest.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
85 | }
86 |
87 | @Test
88 | void test_with_a_real_request_io_error_upon_error_async() throws IOException {
89 | performRequest("http://localhost:8080/async?" + ClientRequest.IO_ERROR_UPON_ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
90 | }
91 |
92 | @Test
93 | void test_with_a_real_request_servlet_error_upon_error_async() throws IOException {
94 | performRequest("http://localhost:8080/async?" + ClientRequest.SERVLET_ERROR_UPON_ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
95 | }
96 |
97 | @Test
98 | void test_with_a_real_request_error_blocking() throws IOException {
99 | performRequest("http://localhost:8080/blocking?" + ClientRequest.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
100 | }
101 |
102 | @Test
103 | void test_with_a_real_request_complex() throws IOException {
104 | performRequest("http://localhost:8080/async?" + ClientRequest.COMPLEX, HttpServletResponse.SC_OK);
105 | }
106 |
107 | private void performRequest(final String url, final int expectedStatus) throws IOException {
108 | ClientRequest.performRequest(url, expectedStatus);
109 | }
110 |
111 | private void performRequest(final String url, final int expectedStatus, final ByteBuffer requestData) throws IOException {
112 | ClientRequest.performRequest(url, expectedStatus, requestData);
113 | }
114 |
115 | @AfterAll
116 | static void tearDown() {
117 | server.stop();
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/ByteBufferBackedInputStreamTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 |
6 | import org.junit.jupiter.api.Test;
7 |
8 | import java.io.IOException;
9 | import java.nio.ByteBuffer;
10 |
11 | class ByteBufferBackedInputStreamTest {
12 |
13 | private static final String TEST_TEXT = "Test text.";
14 |
15 | @Test
16 | void create_with_direct() {
17 | assertThrows(IllegalArgumentException.class, () -> new ByteBufferBackedInputStream(ByteBuffer.allocate(0).asReadOnlyBuffer()));
18 | }
19 |
20 | @Test
21 | void create_with_read_only() {
22 | assertThrows(IllegalArgumentException.class, () -> new ByteBufferBackedInputStream(ByteBuffer.allocateDirect(0)));
23 | }
24 |
25 | @Test
26 | void check_available_bytes() throws Exception {
27 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
28 | final var length = TEST_TEXT.getBytes().length;
29 | assertEquals(length, stream.available());
30 | final var read = stream.read(new byte[1024]);
31 | assertEquals(length, read);
32 | assertEquals(0, stream.available());
33 | }
34 |
35 | @Test
36 | void read_a_byte() throws Exception {
37 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
38 | final var read = stream.read();
39 | assertEquals(read, "T".getBytes()[0]);
40 | }
41 |
42 | @Test
43 | void try_to_read_an_exhausted_stream() throws Exception {
44 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.allocate(0));
45 | final var read = stream.read();
46 | assertEquals(read, -1);
47 | }
48 |
49 | @Test
50 | void try_to_read_a_closed_stream() throws Exception {
51 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
52 | stream.close();
53 | assertThrows(IOException.class, stream::read);
54 | }
55 |
56 | @Test
57 | void read_into_byte_array() throws Exception {
58 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
59 | final var buf = new byte[1024];
60 | final var read = stream.read(buf);
61 | assertEquals(TEST_TEXT, new String(buf, 0, read));
62 | }
63 |
64 | @Test
65 | void try_to_read_an_exhausted_stream_to_array() throws Exception {
66 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.allocate(0));
67 | final var buf = new byte[1024];
68 | final var read = stream.read(buf);
69 | assertEquals(read, -1);
70 | }
71 |
72 | @Test
73 | void try_to_read_a_closed_stream_to_array() throws Exception {
74 | final var stream = new ByteBufferBackedInputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
75 | stream.close();
76 | final var buf = new byte[1024];
77 | assertThrows(IOException.class, () -> stream.read(buf));
78 | }
79 |
80 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/ByteBufferBackedOutputStreamTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 |
6 | import org.junit.jupiter.api.Test;
7 |
8 | import java.io.IOException;
9 | import java.nio.BufferOverflowException;
10 | import java.nio.ByteBuffer;
11 |
12 | class ByteBufferBackedOutputStreamTest {
13 |
14 | private static final String TEST_TEXT = "Test text.";
15 |
16 | @Test
17 | void create_with_direct() {
18 | assertThrows(IllegalArgumentException.class, () -> new ByteBufferBackedOutputStream(ByteBuffer.allocate(0).asReadOnlyBuffer()));
19 | }
20 |
21 | @Test
22 | void create_with_read_only() {
23 | assertThrows(IllegalArgumentException.class, () -> new ByteBufferBackedOutputStream(ByteBuffer.allocateDirect(0)));
24 | }
25 |
26 | @Test
27 | void write_a_byte() throws Exception {
28 | final var buffer = ByteBuffer.allocate(1024);
29 | final var stream = new ByteBufferBackedOutputStream(buffer);
30 | final var oneByte = "T".getBytes()[0];
31 | stream.write(oneByte);
32 | assertEquals(buffer.get(0), oneByte);
33 | }
34 |
35 | @Test
36 | void try_to_write_an_exhausted_stream() {
37 | final var stream = new ByteBufferBackedOutputStream(ByteBuffer.allocate(0));
38 | assertThrows(BufferOverflowException.class, () -> stream.write(1));
39 | }
40 |
41 | @Test
42 | void try_to_write_a_closed_stream() throws Exception {
43 | final var stream = new ByteBufferBackedOutputStream(ByteBuffer.wrap(TEST_TEXT.getBytes()));
44 | stream.close();
45 | assertThrows(IOException.class, () -> stream.write(1));
46 | }
47 |
48 | @Test
49 | void write_into_byte_array() throws IOException {
50 | final var bytes = TEST_TEXT.getBytes();
51 | final var buffer = ByteBuffer.allocate(1024);
52 | final var stream = new ByteBufferBackedOutputStream(buffer);
53 | stream.write(bytes);
54 | assertEquals(TEST_TEXT, new String(buffer.array(), 0, bytes.length));
55 | }
56 |
57 | @Test
58 | void try_to_read_an_exhausted_stream_to_array() {
59 | final var stream = new ByteBufferBackedOutputStream(ByteBuffer.allocate(0));
60 | assertThrows(BufferOverflowException.class, () -> stream.write(TEST_TEXT.getBytes()));
61 | }
62 |
63 | @Test
64 | void try_to_read_a_closed_stream_to_array() throws Exception {
65 | final var stream = new ByteBufferBackedOutputStream(ByteBuffer.allocate(1024));
66 | stream.close();
67 | assertThrows(IOException.class, () -> stream.write(TEST_TEXT.getBytes()));
68 | }
69 |
70 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/InputStreamBackedChannelTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 |
7 | import org.junit.jupiter.api.Test;
8 |
9 | import java.io.ByteArrayInputStream;
10 | import java.io.IOException;
11 | import java.nio.ByteBuffer;
12 | import java.nio.channels.ClosedChannelException;
13 |
14 | class InputStreamBackedChannelTest {
15 |
16 | private static final String TEST_TEXT = "Test text.";
17 |
18 | @Test
19 | void read_the_string() throws Exception {
20 | final var stream = new ByteArrayInputStream(TEST_TEXT.getBytes());
21 | final var channel = new InputStreamBackedChannel(stream);
22 | final var buffer = ByteBuffer.allocate(1024);
23 | channel.read(buffer);
24 | assertEquals(TEST_TEXT, new String(buffer.array(), 0, buffer.position()));
25 | }
26 |
27 | @Test
28 | void try_to_read_to_direct_buffer() {
29 | final var stream = new ByteArrayInputStream(TEST_TEXT.getBytes());
30 | final var channel = new InputStreamBackedChannel(stream);
31 | final var buffer = ByteBuffer.allocateDirect(1024);
32 | assertThrows(IllegalArgumentException.class, () -> channel.read(buffer));
33 | }
34 |
35 | @Test
36 | void try_to_read_to_read_only_buffer() {
37 | final var stream = new ByteArrayInputStream(TEST_TEXT.getBytes());
38 | final var channel = new InputStreamBackedChannel(stream);
39 | final var buffer = ByteBuffer.allocateDirect(1024).asReadOnlyBuffer();
40 | assertThrows(IllegalArgumentException.class, () -> channel.read(buffer));
41 | }
42 |
43 | @Test
44 | void open_and_close_and_try_to_read() throws IOException {
45 | final var stream = new ByteArrayInputStream(TEST_TEXT.getBytes());
46 | final var channel = new InputStreamBackedChannel(stream);
47 | assertTrue(channel.isOpen());
48 | channel.close();
49 | assertThrows(ClosedChannelException.class, () -> channel.read(ByteBuffer.allocate(0)));
50 | }
51 |
52 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/MockServletInputStream.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import java.io.ByteArrayInputStream;
4 | import java.io.IOException;
5 | import java.nio.charset.StandardCharsets;
6 | import jakarta.servlet.ReadListener;
7 | import jakarta.servlet.ServletInputStream;
8 |
9 | public class MockServletInputStream extends ServletInputStream {
10 |
11 | private static final String FILE_NAME = "foo.txt";
12 | private static final String REQUEST_DATA =
13 | "-----1234\r\n"
14 | + "Content-Disposition: form-data; name=\"file\"; filename=\"" + FILE_NAME + "\"\r\n"
15 | + "Content-Type: text/whatever\r\n"
16 | + "\r\n"
17 | + "This is the content of the file\n"
18 | + "\r\n"
19 | + "-----1234\r\n"
20 | + "Content-Disposition: form-data; name=\"field\"\r\n"
21 | + "\r\n"
22 | + "fieldValue\r\n"
23 | + "-----1234\r\n"
24 | + "Content-Disposition: form-data; name=\"multi\"\r\n"
25 | + "\r\n"
26 | + "value1\r\n"
27 | + "-----1234\r\n"
28 | + "Content-Disposition: form-data; name=\"multi\"\r\n"
29 | + "\r\n"
30 | + "value2\r\n"
31 | + "-----1234--\r\n";
32 |
33 | private final ByteArrayInputStream sourceStream;
34 |
35 | private ReadListener readListener;
36 |
37 | MockServletInputStream() {
38 | this.sourceStream = new ByteArrayInputStream(REQUEST_DATA.getBytes(StandardCharsets.US_ASCII));
39 | }
40 |
41 | public void onDataAvailable() throws IOException {
42 | readListener.onDataAvailable();
43 | }
44 |
45 | @Override
46 | public int read() {
47 | return this.sourceStream.read();
48 | }
49 |
50 | @Override
51 | public void close() throws IOException {
52 | super.close();
53 | this.sourceStream.close();
54 | }
55 |
56 | @Override
57 | public boolean isFinished() {
58 | return false;
59 | }
60 |
61 | @Override
62 | public boolean isReady() {
63 | return true;
64 | }
65 |
66 | @Override
67 | public void setReadListener(final ReadListener readListener) {
68 | this.readListener = readListener;
69 | }
70 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/NullChannelTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertFalse;
5 | import static org.junit.jupiter.api.Assertions.assertThrows;
6 | import static org.junit.jupiter.api.Assertions.assertTrue;
7 |
8 | import org.junit.jupiter.api.Test;
9 |
10 | import java.io.IOException;
11 | import java.nio.ByteBuffer;
12 | import java.nio.channels.ClosedChannelException;
13 |
14 | class NullChannelTest {
15 |
16 | @Test
17 | void read_from_open_channel() throws Exception {
18 | final var channel = new NullChannel();
19 | assertEquals(-1, channel.read(ByteBuffer.allocate(0)));
20 | }
21 |
22 | @Test
23 | void read_from_closed_channel() {
24 | final var channel = new NullChannel();
25 | assertTrue(channel.isOpen());
26 | channel.close();
27 | assertFalse(channel.isOpen());
28 | assertThrows(ClosedChannelException.class, () -> channel.read(ByteBuffer.allocate(0)));
29 | }
30 |
31 | @Test
32 | void write_to_open_channel() throws IOException {
33 | final var channel = new NullChannel();
34 | channel.write(ByteBuffer.allocate(0));
35 | }
36 |
37 | @Test
38 | void write_to_closed_channel() {
39 | final var channel = new NullChannel();
40 | assertTrue(channel.isOpen());
41 | channel.close();
42 | assertFalse(channel.isOpen());
43 | assertThrows(ClosedChannelException.class, () -> channel.write(ByteBuffer.allocate(0)));
44 | }
45 |
46 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/OutputStreamBackedChannelTest.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import static org.junit.jupiter.api.Assertions.assertThrows;
5 | import static org.junit.jupiter.api.Assertions.assertTrue;
6 |
7 | import org.junit.jupiter.api.Test;
8 |
9 | import java.io.ByteArrayOutputStream;
10 | import java.io.IOException;
11 | import java.nio.ByteBuffer;
12 | import java.nio.channels.ClosedChannelException;
13 |
14 | class OutputStreamBackedChannelTest {
15 |
16 | private static final String TEST_TEXT = "Test text.";
17 |
18 | @Test
19 | void write_the_string() throws IOException {
20 | final var stream = new ByteArrayOutputStream(1024);
21 | final var channel = new OutputStreamBackedChannel(stream);
22 | final var buffer = ByteBuffer.wrap(TEST_TEXT.getBytes());
23 | channel.write(buffer);
24 | assertEquals(TEST_TEXT, new String(buffer.array(), 0, buffer.position()));
25 | }
26 |
27 | @Test
28 | void try_to_write_from_direct_buffer() {
29 | final var stream = new ByteArrayOutputStream(1024);
30 | final var channel = new OutputStreamBackedChannel(stream);
31 | final var buffer = ByteBuffer.allocateDirect(0);
32 | assertThrows(IllegalArgumentException.class, () -> channel.write(buffer));
33 | }
34 |
35 | @Test
36 | void try_to_write_from_read_only_buffer() {
37 | final var stream = new ByteArrayOutputStream(1024);
38 | final var channel = new OutputStreamBackedChannel(stream);
39 | final var buffer = ByteBuffer.allocate(0).asReadOnlyBuffer();
40 | assertThrows(IllegalArgumentException.class, () -> channel.write(buffer));
41 | }
42 |
43 | @Test
44 | void open_and_close_and_try_to_write() throws Exception {
45 | final var stream = new ByteArrayOutputStream(1024);
46 | final var channel = new OutputStreamBackedChannel(stream);
47 | assertTrue(channel.isOpen());
48 | channel.close();
49 | assertThrows(ClosedChannelException.class, () -> channel.write(ByteBuffer.wrap(TEST_TEXT.getBytes())));
50 | }
51 |
52 | }
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/java/com/github/elopteryx/upload/util/Servlets.java:
--------------------------------------------------------------------------------
1 | package com.github.elopteryx.upload.util;
2 |
3 | import static org.mockito.Mockito.mock;
4 | import static org.mockito.Mockito.when;
5 |
6 | import jakarta.servlet.http.HttpServletRequest;
7 | import jakarta.servlet.http.HttpServletResponse;
8 |
9 | public final class Servlets {
10 |
11 | private Servlets() {
12 | // No need to instantiate
13 | }
14 |
15 | /**
16 | * Creates a new mock servlet request.
17 | * @return The mocked request.
18 | * @throws Exception If an error occurred
19 | */
20 | public static HttpServletRequest newRequest() throws Exception {
21 | final var request = mock(HttpServletRequest.class);
22 |
23 | when(request.getMethod()).thenReturn("POST");
24 | when(request.getContentType()).thenReturn("multipart/");
25 | when(request.getContentLengthLong()).thenReturn(1024 * 1024L);
26 | when(request.getInputStream()).thenReturn(new MockServletInputStream());
27 | when(request.isAsyncSupported()).thenReturn(true);
28 |
29 | return request;
30 | }
31 |
32 | /**
33 | * Creates a new mock servlet response.
34 | * @return The mocked response.
35 | */
36 | public static HttpServletResponse newResponse() {
37 | final var response = mock(HttpServletResponse.class);
38 |
39 | when(response.getStatus()).thenReturn(200);
40 |
41 | return response;
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Elopteryx/upload-parser/ae2ea72fedea25bd051823677241c05489d2df06/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.docx
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Elopteryx/upload-parser/ae2ea72fedea25bd051823677241c05489d2df06/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.jpg
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Elopteryx/upload-parser/ae2ea72fedea25bd051823677241c05489d2df06/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/integration/test.xlsx
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime-utf8.txt:
--------------------------------------------------------------------------------
1 | This is a preamble
2 | --unique-boundary-1
3 | Content-type: text/plain
4 | Content-Disposition: attachment; filename=个专为语文教学而设计的电脑软件.txt
5 |
6 | Just some chinese characters I copied from the internet, no idea what it says.
7 | --unique-boundary-1--
8 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime1.txt:
--------------------------------------------------------------------------------
1 | this is a preamble
2 | --unique-boundary-1
3 | Content-type: text/plain
4 |
5 | Here is some text.
6 | --unique-boundary-1
7 |
8 | Here is some more text.
9 | --unique-boundary-1--
10 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime2.txt:
--------------------------------------------------------------------------------
1 | --unique-boundary-1
2 | Content-type: text/plain
3 |
4 | Here is some text.
5 | --unique-boundary-1
6 |
7 | Here is some more text.
8 | --unique-boundary-1--
9 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime3.txt:
--------------------------------------------------------------------------------
1 | --unique-boundary-1
2 | Content-type: text/plain
3 | Content-Transfer-encoding: base64
4 |
5 | VGhpcyBpcyBzb21lIGJhc2U2NCB0ZXh0Lg==
6 | --unique-boundary-1
7 | Content-Transfer-encoding: base64
8 |
9 | VGhpcyBpcyBzb21lIG1vcmUgYmFzZTY0IHRleHQu
10 | --unique-boundary-1--
11 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime4.txt:
--------------------------------------------------------------------------------
1 | --someboundarytext
2 | Content-type: text/plain
3 | Content-Transfer-encoding: quoted-printable
4 |
5 | time=3Dmoney.
6 | --someboundarytext--
7 |
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime5_malformed.txt:
--------------------------------------------------------------------------------
1 | this is a preamble
2 | --unique-boundary-1
3 | Content-type: text/plain
4 |
5 | Here is some text.
6 | --unique-boundary-1
7 |
8 | Here is some more text.
9 | --unique-boundary-1---
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime6_malformed.txt:
--------------------------------------------------------------------------------
1 | --unique-boundary-1
2 | Content-type: text/plain
3 | Content-Transfer-encoding: base64
4 |
5 | vGhpcyBpcyBzb21lIGJhc2U2NCB0ZXh0Lg===
6 | --unique-boundary-1
7 | Content-Transfer-encoding: base64
8 |
9 | vGhpcyBpcyBzb21lIG1vcmUgYmFzZTY0IHRleHQu=
10 | --unique-boundary-1--
--------------------------------------------------------------------------------
/upload-parser-tests/src/test/resources/com/github/elopteryx/upload/internal/mime7_malformed.txt:
--------------------------------------------------------------------------------
1 | --someboundarytext
2 | Content-type: text/plain
3 | Content-Transfer-encoding: quoted-printable
4 |
5 | time=
6 | money.
7 | --someboundarytext--
--------------------------------------------------------------------------------