/**
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
*
* The Apereo Foundation licenses this file to you under the Educational
* Community License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License
* at:
*
* http://opensource.org/licenses/ecl2.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
*/
package org.opencastproject.staticfiles.endpoint;
import static org.easymock.EasyMock.anyObject;
import static org.easymock.EasyMock.eq;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import org.opencastproject.security.api.DefaultOrganization;
import org.opencastproject.security.api.Organization;
import org.opencastproject.security.api.SecurityService;
import org.opencastproject.staticfiles.api.StaticFileService;
import org.opencastproject.systems.MatterhornConstants;
import org.opencastproject.util.NotFoundException;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.MockHttpServletRequest;
import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.osgi.framework.BundleContext;
import org.osgi.service.cm.ConfigurationException;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Dictionary;
import java.util.Properties;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
public class StaticFileRestServiceTest {
private static final String MOCK_FILE_CONTENT = "This is the content of the file\n";
private static final Logger logger = LoggerFactory.getLogger(StaticFileRestServiceTest.class);
private static final String SERVER_URL = "http://localhost:8080";
private static final String WEBSERVER_URL = "http://localhost/staticfiles";
private static String videoFilename = "av.mov";
private static String imageFilename = "image.jpg";
/** The File object that is an example image */
private static File imageFile;
/** Location where the files are copied to */
private static File rootDir;
/** The File object that is an example video */
private static File videoFile;
/** The org to use for the tests */
private static Organization org = new DefaultOrganization();
/** The test root directory */
private static URI baseDir;
@BeforeClass
public static void beforeClass() throws URISyntaxException {
// baseDir = StaticFileServiceImplTest.class.getResource("/").toURI();
// rootDir = new File(new File(baseDir), "ingest-temp");
// imageFile = new File(StaticFileServiceImplTest.class.getResource("/" + imageFilename).getPath());
// videoFile = new File(StaticFileServiceImplTest.class.getResource("/" + videoFilename).getPath());
}
@Before
public void setUp() throws IOException {
// FileUtils.forceMkdir(rootDir);
}
@After
public void tearDown() {
// FileUtils.deleteQuietly(rootDir);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private static ComponentContext getComponentContext(String useWebserver, long maxSize) {
// Create BundleContext
BundleContext bundleContext = EasyMock.createMock(BundleContext.class);
EasyMock.expect(bundleContext.getProperty(MatterhornConstants.SERVER_URL_PROPERTY)).andReturn(SERVER_URL);
EasyMock.expect(bundleContext.getProperty(StaticFileRestService.STATICFILES_UPLOAD_MAX_SIZE_KEY)).andReturn(
Long.toString(maxSize));
EasyMock.replay(bundleContext);
// Create ComponentContext
Dictionary properties = new Properties();
if (useWebserver != null) {
properties.put(StaticFileRestService.STATICFILES_WEBSERVER_ENABLED_KEY, useWebserver);
}
properties.put(StaticFileRestService.STATICFILES_WEBSERVER_URL_KEY, WEBSERVER_URL);
ComponentContext cc = EasyMock.createMock(ComponentContext.class);
EasyMock.expect(cc.getProperties()).andReturn(properties).anyTimes();
EasyMock.expect(cc.getBundleContext()).andReturn(bundleContext).anyTimes();
EasyMock.replay(cc);
return cc;
}
private static SecurityService getSecurityService() {
SecurityService securityService = EasyMock.createMock(SecurityService.class);
EasyMock.expect(securityService.getOrganization()).andReturn(org).anyTimes();
EasyMock.replay(securityService);
return securityService;
}
private MockHttpServletRequest newMockRequest() throws Exception {
StringBuilder requestBody = new StringBuilder();
requestBody.append("-----1234\r\n");
requestBody.append("Content-Disposition: form-data; name=\"file\"; filename=\"other.mov\"\r\n");
requestBody.append("Content-Type: text/whatever\r\n");
requestBody.append("\r\n");
requestBody.append(MOCK_FILE_CONTENT);
requestBody.append("\r\n");
requestBody.append("-----1234");
return new MockHttpServletRequest(requestBody.toString().getBytes("UTF-8"), "multipart/form-data; boundary=---1234");
}
private MockHttpServletRequest newUnsizedMockRequest() throws Exception {
StringBuilder requestBody = new StringBuilder();
requestBody.append("-----1234\r\n");
requestBody.append("Content-Disposition: form-data; name=\"file\"; filename=\"other.mov\"\r\n");
requestBody.append("Content-Type: text/whatever\r\n");
requestBody.append("\r\n");
requestBody.append(MOCK_FILE_CONTENT);
requestBody.append("\r\n");
requestBody.append("-----1234");
return new MockHttpServletRequest(new ByteArrayInputStream(requestBody.toString().getBytes("UTF-8")), -1,
"multipart/form-data; boundary=---1234");
}
@Test
public void testUseWebserver() throws ConfigurationException {
StaticFileRestService staticFileRestService = new StaticFileRestService();
staticFileRestService.activate(getComponentContext(null, 100000000L));
assertFalse(staticFileRestService.useWebserver);
staticFileRestService.activate(getComponentContext("", 100000000L));
assertFalse(staticFileRestService.useWebserver);
staticFileRestService.activate(getComponentContext("false", 100000000L));
assertFalse(staticFileRestService.useWebserver);
staticFileRestService.activate(getComponentContext("other", 100000000L));
assertFalse(staticFileRestService.useWebserver);
staticFileRestService.activate(getComponentContext("true", 100000000L));
assertTrue(staticFileRestService.useWebserver);
}
@Test
public void testStoreStaticFileInputHttpServletRequest() throws FileUploadException, Exception {
// Setup static file service.
StaticFileService fileService = EasyMock.createMock(StaticFileService.class);
String fileUuid = "12345";
String fileName = "other.mov";
EasyMock.expect(fileService.storeFile(eq(fileName), anyObject(InputStream.class))).andReturn(fileUuid);
EasyMock.expect(fileService.getFileName(fileUuid)).andReturn(fileName);
EasyMock.replay(fileService);
// Run the test
StaticFileRestService staticFileRestService = new StaticFileRestService();
staticFileRestService.activate(getComponentContext(null, 100000000L));
staticFileRestService.setSecurityService(getSecurityService());
staticFileRestService.setStaticFileService(fileService);
// Test a good store request
Response result = staticFileRestService.postStaticFile(newMockRequest());
assertEquals(Status.CREATED.getStatusCode(), result.getStatus());
assertTrue(result.getMetadata().size() > 0);
assertTrue(result.getMetadata().get("location").size() > 0);
String location = result.getMetadata().get("location").get(0).toString();
String uuid = location.substring(location.lastIndexOf("/") + 1);
// assertTrue(IOUtils.contentEquals(new ByteArrayInputStream(MOCK_FILE_CONTENT.getBytes("UTF-8")),
// staticFileServiceImpl.getFile(uuid)));
// Test a request with too large of an input stream
HttpServletRequest tooLargeRequest = EasyMock.createMock(HttpServletRequest.class);
EasyMock.expect(tooLargeRequest.getContentLength()).andReturn(1000000000).anyTimes();
EasyMock.replay(tooLargeRequest);
result = staticFileRestService.postStaticFile(tooLargeRequest);
assertEquals(Status.BAD_REQUEST.getStatusCode(), result.getStatus());
staticFileRestService.activate(getComponentContext("true", 100000000L));
URI staticFileURL = staticFileRestService.getStaticFileURL(uuid);
assertEquals("http://localhost/staticfiles/mh_default_org/" + uuid + "/other.mov", staticFileURL.toString());
}
@Test
public void testUploadMaxSizeReached() throws FileUploadException, Exception {
// Setup static file service.
StaticFileService fileService = EasyMock.createMock(StaticFileService.class);
EasyMock.expect(fileService.storeFile(eq("other.mov"), anyObject(InputStream.class))).andReturn("12345");
EasyMock.replay(fileService);
// Run the test
StaticFileRestService staticFileRestService = new StaticFileRestService();
staticFileRestService.activate(getComponentContext(null, 10L));
staticFileRestService.setSecurityService(getSecurityService());
staticFileRestService.setStaticFileService(fileService);
// Test a sized mock request
Response result = staticFileRestService.postStaticFile(newMockRequest());
assertEquals(Status.BAD_REQUEST.getStatusCode(), result.getStatus());
}
@Test
public void testDeleteStaticFile() throws FileUploadException, Exception {
// Setup static file service.
StaticFileService fileService = EasyMock.createMock(StaticFileService.class);
final String fileUuid = "12345";
EasyMock.expect(fileService.storeFile(anyObject(String.class), anyObject(InputStream.class))).andReturn(fileUuid);
fileService.deleteFile(fileUuid);
EasyMock.expectLastCall();
EasyMock.expect(fileService.getFile(fileUuid)).andThrow(new NotFoundException());
EasyMock.replay(fileService);
// Run the test
StaticFileRestService staticFileRestService = new StaticFileRestService();
staticFileRestService.activate(getComponentContext(null, 100000000L));
staticFileRestService.setSecurityService(getSecurityService());
staticFileRestService.setStaticFileService(fileService);
// Test a good store request
Response result = staticFileRestService.postStaticFile(newMockRequest());
assertEquals(Status.CREATED.getStatusCode(), result.getStatus());
String location = result.getMetadata().get("location").get(0).toString();
String uuid = location.substring(location.lastIndexOf("/") + 1);
Response response = staticFileRestService.deleteStaticFile(uuid);
assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
try {
staticFileRestService.getStaticFile(uuid);
fail("NotFoundException must be passed on");
} catch (NotFoundException e) {
// expected
}
}
}