Migrated FTP Channel Adapter code from the 'org.springframework.integration.adapter' module to the new 'org.springframework.integration.ftp' module.
This commit is contained in:
Mark Fisher
@@ -1,168 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.concurrent.PriorityBlockingQueue;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.beans.DirectFieldAccessor;
|
||||
import org.springframework.integration.adapter.ftp.Backlog;
|
||||
import org.springframework.integration.adapter.ftp.FileSnapshot;
|
||||
|
||||
/**
|
||||
* @author Marius Bogoevici
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class BacklogTests {
|
||||
|
||||
private Backlog<FileSnapshot> backlog;
|
||||
|
||||
private ArrayList<FileSnapshot> remoteSnapshot;
|
||||
|
||||
private FileSnapshot[] process;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
backlog = new Backlog<FileSnapshot>();
|
||||
process = new FileSnapshot[5];
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInitialization() {
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
Assert.assertEquals(3, queue.size());
|
||||
Assert.assertTrue(queue.containsAll(remoteSnapshot));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFullProcessingInOneStep() {
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.toArray(process));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFullProcessingInTwoSteps() {
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.subList(0, 2).toArray(process));
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
Assert.assertEquals(1, queue.size());
|
||||
Assert.assertTrue(queue.contains(remoteSnapshot.get(2)));
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(1, queue.size());
|
||||
Assert.assertTrue(queue.contains(remoteSnapshot.get(2)));
|
||||
backlog.fileProcessed(remoteSnapshot.get(2));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOneFileChangedSize() {
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.toArray(process));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
remoteSnapshot.remove(2);
|
||||
FileSnapshot modifiedC = new FileSnapshot("c.txt", 1001, 112);
|
||||
remoteSnapshot.add(modifiedC);
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(1, queue.size());
|
||||
Assert.assertTrue(queue.contains(modifiedC));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOneFileChangedDate() {
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.toArray(process));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
remoteSnapshot.remove(2);
|
||||
FileSnapshot modifiedC = new FileSnapshot("c.txt", 1011, 102);
|
||||
remoteSnapshot.add(modifiedC);
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(1, queue.size());
|
||||
Assert.assertTrue(queue.contains(modifiedC));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOneFileAdded() {
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.toArray(process));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
FileSnapshot newD = new FileSnapshot("d.txt", 1003, 103);
|
||||
remoteSnapshot.add(newD);
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(1, queue.size());
|
||||
Assert.assertTrue(queue.contains(newD));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOneFileRemoved() {
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
backlog.fileProcessed( remoteSnapshot.toArray(process));
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
remoteSnapshot.remove(2);
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertTrue(backlog.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOneFileRemovedBeforeBeingProcessedInTheNextStep() {
|
||||
PriorityBlockingQueue<FileSnapshot> queue = (PriorityBlockingQueue<FileSnapshot>) new DirectFieldAccessor(
|
||||
backlog).getPropertyValue("backlog");
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(3, queue.size());
|
||||
remoteSnapshot.remove(2);
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(2, queue.size());
|
||||
backlog.processSnapshot(remoteSnapshot);
|
||||
Assert.assertEquals(2, queue.size());
|
||||
}
|
||||
|
||||
// @Test selectForProcessing success/failure
|
||||
|
||||
@Before
|
||||
public void generateInitialSnapshot() {
|
||||
this.remoteSnapshot = new ArrayList<FileSnapshot>();
|
||||
remoteSnapshot.add(new FileSnapshot("a.txt", 1000, 100));
|
||||
remoteSnapshot.add(new FileSnapshot("b.txt", 1001, 101));
|
||||
remoteSnapshot.add(new FileSnapshot("c.txt", 1002, 102));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.beans.DirectFieldAccessor;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public class ConcurrentBacklogTests {
|
||||
|
||||
@Test(timeout = 1000)
|
||||
public void simultaniousPreparation() throws Exception {
|
||||
final Backlog backlog = new Backlog();
|
||||
backlog.processSnapshot(Arrays.asList(new String[] { "bert", "ernie", "pino", "whatsherface" }));
|
||||
Runnable todo = new Runnable() {
|
||||
public void run() {
|
||||
backlog.prepareForProcessing(1);
|
||||
}
|
||||
};
|
||||
CountDownLatch start = new CountDownLatch(1);
|
||||
CountDownLatch done = doConcurrently(5, todo, start);
|
||||
start.countDown();
|
||||
try {
|
||||
done.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
assertTrue(backlog.isEmpty());
|
||||
}
|
||||
|
||||
@Test(timeout = 1000)
|
||||
public void concurrentUnloading() throws Exception {
|
||||
final Backlog backlog = new Backlog();
|
||||
List<String> items = Arrays.asList(new String[] { "bert", "ernie", "pino", "whatsherface", "kaas", "pasf" });
|
||||
backlog.processSnapshot(items);
|
||||
final AtomicBoolean properlyUnloaded = new AtomicBoolean(false);
|
||||
Runnable todo = new Runnable() {
|
||||
public void run() {
|
||||
backlog.prepareForProcessing(2);
|
||||
backlog.processed();
|
||||
properlyUnloaded.set(backlog.isEmpty() && backlog.getProcessingBuffer().isEmpty());
|
||||
}
|
||||
};
|
||||
CountDownLatch start = new CountDownLatch(1);
|
||||
CountDownLatch done = doConcurrently(3, todo, start);
|
||||
start.countDown();
|
||||
try {
|
||||
done.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
assertTrue("currentlyProcessing not emptied correctly", ((Collection) new DirectFieldAccessor(backlog)
|
||||
.getPropertyValue("currentlyProcessing")).isEmpty());
|
||||
assertTrue("doneProcessing not populated correctly", ((Collection) new DirectFieldAccessor(backlog)
|
||||
.getPropertyValue("doneProcessing")).containsAll(items));
|
||||
}
|
||||
|
||||
@Test(timeout = 1000)
|
||||
public void concurrentFailing() throws Exception {
|
||||
final Backlog backlog = new Backlog();
|
||||
List<String> items = Arrays.asList(new String[] { "bert", "ernie", "pino", "whatsherface", "kaas", "pasf" });
|
||||
backlog.processSnapshot(items);
|
||||
final AtomicBoolean properlyBackedUp = new AtomicBoolean(false);
|
||||
Runnable todo = new Runnable() {
|
||||
public void run() {
|
||||
backlog.prepareForProcessing(2);
|
||||
backlog.processingFailed();
|
||||
properlyBackedUp.set(backlog.getProcessingBuffer().isEmpty());
|
||||
}
|
||||
};
|
||||
CountDownLatch start = new CountDownLatch(1);
|
||||
CountDownLatch done = doConcurrently(3, todo, start);
|
||||
start.countDown();
|
||||
try {
|
||||
done.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
assertTrue("currentlyProcessing not emptied correctly", ((Collection) new DirectFieldAccessor(backlog)
|
||||
.getPropertyValue("currentlyProcessing")).isEmpty());
|
||||
assertTrue("backlog not repopulated correctly", ((Collection) new DirectFieldAccessor(backlog)
|
||||
.getPropertyValue("backlog")).containsAll(items));
|
||||
}
|
||||
|
||||
@Test(timeout = 1000)
|
||||
public void concurrentSuccessFailure() throws Exception {
|
||||
final Backlog backlog = new Backlog();
|
||||
List<String> items = Arrays.asList(new String[] { "ham", "chicken", "burger", "cheeze" });
|
||||
backlog.processSnapshot(items);
|
||||
final AtomicBoolean properlyBackedUp = new AtomicBoolean(true);
|
||||
final AtomicBoolean properlyUnloaded = new AtomicBoolean(true);
|
||||
Runnable doFailure = new Runnable() {
|
||||
public void run() {
|
||||
backlog.prepareForProcessing(1);
|
||||
backlog.processingFailed();
|
||||
properlyBackedUp.set(backlog.getProcessingBuffer().isEmpty() && properlyBackedUp.get());
|
||||
}
|
||||
};
|
||||
Runnable doSuccess = new Runnable() {
|
||||
public void run() {
|
||||
backlog.prepareForProcessing(1);
|
||||
//make sure we process a message
|
||||
while (backlog.getProcessingBuffer().size() == 0) {
|
||||
Thread.yield();
|
||||
backlog.prepareForProcessing(1);
|
||||
}
|
||||
backlog.processed();
|
||||
properlyUnloaded.set(backlog.getProcessingBuffer().isEmpty() && properlyUnloaded.get());
|
||||
}
|
||||
};
|
||||
CountDownLatch start = new CountDownLatch(1);
|
||||
CountDownLatch doneFailure = doConcurrently(20, doFailure, start);
|
||||
CountDownLatch doneSuccess = doConcurrently(2, doSuccess, start);
|
||||
start.countDown();
|
||||
try {
|
||||
doneSuccess.await();
|
||||
doneFailure.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
assertTrue(properlyBackedUp.get());
|
||||
assertTrue(properlyUnloaded.get());
|
||||
assertTrue("currentlyProcessing not emptied correctly", ((Collection) new DirectFieldAccessor(backlog)
|
||||
.getPropertyValue("currentlyProcessing")).isEmpty());
|
||||
Collection backlogQueue = (Collection) new DirectFieldAccessor(backlog).getPropertyValue("backlog");
|
||||
assertTrue("backlog not repopulated correctly size is " + backlogQueue.size(), backlogQueue.size() == 2);
|
||||
Collection doneProcessing = (Collection) new DirectFieldAccessor(backlog).getPropertyValue("doneProcessing");
|
||||
assertTrue("doneProcessing not repopulated correctly size is " + doneProcessing.size(),
|
||||
doneProcessing.size() == 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convenience method to run part of a test concurrently in multiple threads
|
||||
*
|
||||
* @param numberOfThreads
|
||||
* @param todo the runnable that should be run by all the threads
|
||||
* @return a latch that will be counted down once all threads have run their
|
||||
* runnable.
|
||||
*/
|
||||
private CountDownLatch doConcurrently(int numberOfThreads, final Runnable todo, final CountDownLatch start) {
|
||||
final CountDownLatch started = new CountDownLatch(numberOfThreads);
|
||||
final CountDownLatch done = new CountDownLatch(numberOfThreads);
|
||||
for (int i = 0; i < numberOfThreads; i++) {
|
||||
new Thread(new Runnable() {
|
||||
|
||||
public void run() {
|
||||
started.countDown();
|
||||
try {
|
||||
started.await();
|
||||
start.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
todo.run();
|
||||
done.countDown();
|
||||
}
|
||||
}).start();
|
||||
}
|
||||
return done;
|
||||
}
|
||||
}
|
||||
@@ -1,282 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp;
|
||||
|
||||
import static org.easymock.EasyMock.eq;
|
||||
import static org.easymock.EasyMock.expect;
|
||||
import static org.easymock.EasyMock.getCurrentArguments;
|
||||
import static org.easymock.EasyMock.isA;
|
||||
import static org.easymock.classextension.EasyMock.createMock;
|
||||
import static org.easymock.classextension.EasyMock.createNiceMock;
|
||||
import static org.easymock.classextension.EasyMock.replay;
|
||||
import static org.easymock.classextension.EasyMock.reset;
|
||||
import static org.easymock.classextension.EasyMock.verify;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FilenameFilter;
|
||||
import java.io.OutputStream;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Calendar;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
|
||||
import org.apache.commons.net.ftp.FTPClient;
|
||||
import org.apache.commons.net.ftp.FTPFile;
|
||||
import org.apache.oro.io.Perl5FilenameFilter;
|
||||
import org.easymock.IAnswer;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Before;
|
||||
import org.junit.Ignore;
|
||||
import org.junit.Test;
|
||||
import org.springframework.integration.message.GenericMessage;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageCreator;
|
||||
|
||||
/**
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class FtpSourceTests {
|
||||
|
||||
private MessageCreator<List<File>, List<File>> messageCreator = createMock(MessageCreator.class);
|
||||
|
||||
private FTPClient ftpClient = createMock(FTPClient.class);
|
||||
|
||||
private FTPFile ftpFile = createMock(FTPFile.class);
|
||||
|
||||
private FTPClientPool ftpClientPool = createNiceMock(FTPClientPool.class);
|
||||
|
||||
@Before
|
||||
public void liberalPool() throws Exception {
|
||||
expect(ftpClientPool.getClient()).andReturn(ftpClient).anyTimes();
|
||||
}
|
||||
|
||||
private Object[] globalMocks = new Object[] { messageCreator, ftpClient, ftpFile, ftpClientPool };
|
||||
|
||||
private FtpSource ftpSource;
|
||||
|
||||
private Long size = 100l;
|
||||
|
||||
@Before
|
||||
public void initializeFtpSource() {
|
||||
ftpSource = new FtpSource(messageCreator, ftpClientPool);
|
||||
}
|
||||
|
||||
@Before
|
||||
public void clearState() {
|
||||
reset(globalMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void retrieveSingleFile() throws Exception {
|
||||
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFilesNamed("test1"));
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
// create message
|
||||
expect(messageCreator.createMessage(isA(List.class))).andReturn(
|
||||
new GenericMessage(Arrays.asList(new File("test1"))));
|
||||
replay(globalMocks);
|
||||
Message<List<File>> received = ftpSource.receive();
|
||||
ftpSource.onSend(received);
|
||||
verify(globalMocks);
|
||||
}
|
||||
|
||||
private FTPFile[] mockedFTPFilesNamed(String... names) {
|
||||
List<FTPFile> files = new ArrayList<FTPFile>();
|
||||
// ensure difference by increasing size
|
||||
Calendar timestamp = Calendar.getInstance();
|
||||
size++;
|
||||
for (String name : names) {
|
||||
FTPFile ftpFile = createMock(FTPFile.class);
|
||||
expect(ftpFile.getName()).andReturn(name).anyTimes();
|
||||
expect(ftpFile.getTimestamp()).andReturn(timestamp).anyTimes();
|
||||
expect(ftpFile.getSize()).andReturn(size).anyTimes();
|
||||
files.add(ftpFile);
|
||||
replay(ftpFile);
|
||||
}
|
||||
return files.toArray(new FTPFile[] {});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void retrieveMultipleFiles() throws Exception {
|
||||
// get files
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFilesNamed("test1", "test2")).times(2);
|
||||
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test2"), isA(OutputStream.class))).andReturn(true);
|
||||
// create message
|
||||
List<File> files = Arrays.asList(new File("test1"), new File("test2"));
|
||||
expect(messageCreator.createMessage(isA(List.class))).andReturn(new GenericMessage(files));
|
||||
|
||||
replay(globalMocks);
|
||||
Message receivedFiles = ftpSource.receive();
|
||||
ftpSource.onSend(receivedFiles);
|
||||
Message<List<File>> secondReceived = ftpSource.receive();
|
||||
verify(globalMocks);
|
||||
assertEquals(files, receivedFiles.getPayload());
|
||||
assertNull(secondReceived);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void retrieveMultipleChangingFiles() throws Exception {
|
||||
// first run
|
||||
FTPFile[] mockedFTPFiles = mockedFTPFilesNamed("test1", "test2");
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles);
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test2"), isA(OutputStream.class))).andReturn(true);
|
||||
|
||||
// second run, change the date so the messages should be retrieved again
|
||||
// expect(ftpClient.isConnected()).andReturn(true);
|
||||
FTPFile[] mockedFTPFiles2 = mockedFTPFilesNamed("test1", "test2");
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles2);
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test2"), isA(OutputStream.class))).andReturn(true);
|
||||
// create message
|
||||
List<File> files = Arrays.asList(new File("test1"), new File("test2"));
|
||||
expect(messageCreator.createMessage(isA(List.class))).andReturn(new GenericMessage(files)).times(2);
|
||||
|
||||
replay(globalMocks);
|
||||
Message receivedFiles = ftpSource.receive();
|
||||
ftpSource.onSend(receivedFiles);
|
||||
ftpSource.onSend(ftpSource.receive());
|
||||
verify(globalMocks);
|
||||
assertEquals(files, receivedFiles.getPayload());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void retrieveMaxFilesPerMessage() throws Exception {
|
||||
|
||||
this.ftpSource.setMaxFilesPerMessage(2);
|
||||
// assume client already connected
|
||||
FTPFile[] mockedFTPFiles = mockedFTPFilesNamed("test1", "test2", "test3");
|
||||
|
||||
// expect two receive runs
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles).times(2);
|
||||
|
||||
// first run
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test2"), isA(OutputStream.class))).andReturn(true);
|
||||
// second run
|
||||
expect(ftpClient.retrieveFile(eq("test3"), isA(OutputStream.class))).andReturn(true);
|
||||
|
||||
// create message
|
||||
expect(messageCreator.createMessage(isA(List.class))).andAnswer(new IAnswer<Message<List<File>>>() {
|
||||
public Message<List<File>> answer() throws Throwable {
|
||||
return new GenericMessage(getCurrentArguments()[0]);
|
||||
}
|
||||
}).times(2);
|
||||
|
||||
replay(globalMocks);
|
||||
Message<List<File>> receivedFiles1 = ftpSource.receive();
|
||||
ftpSource.onSend(receivedFiles1);
|
||||
Message<List<File>> receivedFiles2 = ftpSource.receive();
|
||||
ftpSource.onSend(receivedFiles2);
|
||||
verify(globalMocks);
|
||||
List<File> allReceived = new ArrayList<File>(receivedFiles1.getPayload());
|
||||
allReceived.addAll(receivedFiles2.getPayload());
|
||||
assertEquals(2, receivedFiles1.getPayload().size());
|
||||
assertEquals(1, receivedFiles2.getPayload().size());
|
||||
assertTrue(allReceived.containsAll(Arrays.asList(new File[] { new File("test1"), new File("test2"),
|
||||
new File("test3") })));
|
||||
}
|
||||
|
||||
@Test(timeout = 6000)
|
||||
@Ignore //not reliable
|
||||
public void concurrentPollingSunnyDay() throws Exception {
|
||||
final CountDownLatch recorded = new CountDownLatch(1);
|
||||
this.ftpSource.setMaxFilesPerMessage(2);
|
||||
// first run
|
||||
FTPFile[] mockedFTPFiles = mockedFTPFilesNamed("test1", "test2", "test3", "test4", "test5");
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles);
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test2"), isA(OutputStream.class))).andReturn(true);
|
||||
|
||||
// second poll
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles);
|
||||
expect(ftpClient.retrieveFile(eq("test3"), isA(OutputStream.class))).andReturn(true);
|
||||
expect(ftpClient.retrieveFile(eq("test4"), isA(OutputStream.class))).andReturn(true);
|
||||
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFiles);
|
||||
expect(ftpClient.retrieveFile(eq("test5"), isA(OutputStream.class))).andReturn(true);
|
||||
// create message
|
||||
expect(messageCreator.createMessage(isA(List.class))).andAnswer(new IAnswer<Message<List<File>>>() {
|
||||
public Message<List<File>> answer() throws Throwable {
|
||||
return new GenericMessage(getCurrentArguments()[0]);
|
||||
}
|
||||
}).times(3);
|
||||
replay(globalMocks);
|
||||
recorded.countDown();
|
||||
|
||||
final CountDownLatch receivesDone = new CountDownLatch(3);
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
new Thread(new Runnable() {
|
||||
public void run() {
|
||||
Message<List<File>> recievedFiles = null;
|
||||
try {
|
||||
// make sure receive happens after recording
|
||||
recorded.await();
|
||||
recievedFiles = ftpSource.receive();
|
||||
receivesDone.countDown();
|
||||
// make sure onSend happens after all receives
|
||||
receivesDone.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
}
|
||||
finally {
|
||||
ftpSource.onSend(recievedFiles);
|
||||
}
|
||||
}
|
||||
}).start();
|
||||
}
|
||||
try {
|
||||
receivesDone.await();
|
||||
}
|
||||
catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
verify(globalMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onFailure() throws Exception {
|
||||
expect(ftpClient.listFiles()).andReturn(mockedFTPFilesNamed("test1")).times(2);
|
||||
expect(ftpClient.retrieveFile(eq("test1"), isA(OutputStream.class))).andReturn(true).times(2);
|
||||
// create message
|
||||
expect(messageCreator.createMessage(isA(List.class))).andReturn(
|
||||
new GenericMessage(Arrays.asList(new File("test1")))).times(2);
|
||||
replay(globalMocks);
|
||||
Message<List<File>> received = ftpSource.receive();
|
||||
ftpSource.onFailure(received, new Exception("just a test"));
|
||||
assertEquals(received, ftpSource.receive());
|
||||
verify(globalMocks);
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void deleteFiles() {
|
||||
File file = new File("./");
|
||||
File[] files = file.listFiles((FilenameFilter) new Perl5FilenameFilter("test\\d"));
|
||||
for (File file2 : files) {
|
||||
file2.delete();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.integration.adapter.ftp;
|
||||
|
||||
import static org.easymock.classextension.EasyMock.*;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
|
||||
import org.apache.commons.net.ftp.FTPClient;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageMapper;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Iwein Fuld
|
||||
*
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public class FtpTargetTest {
|
||||
|
||||
private FtpTarget ftpTarget;
|
||||
|
||||
// Mocks and initialization
|
||||
private MessageMapper<?, File> messageMapper = createMock(MessageMapper.class);
|
||||
|
||||
private Message message = createMock(Message.class);
|
||||
|
||||
private FTPClient ftpClient = createMock(FTPClient.class);
|
||||
|
||||
/*
|
||||
* We don't want tests to worry about interaction with the pool (with the
|
||||
* exception of one dedicated test), so let's make the pool as transparent
|
||||
* as possible.
|
||||
*/
|
||||
private FTPClientPool ftpClientPool = createNiceMock(FTPClientPool.class);
|
||||
|
||||
@Before
|
||||
public void liberalPool() throws Exception {
|
||||
expect(ftpClientPool.getClient()).andReturn(ftpClient).anyTimes();
|
||||
}
|
||||
|
||||
/*
|
||||
* Handle to all mocks in this test so you can't forget to include one in a
|
||||
* replay, verify or reset call.
|
||||
*/
|
||||
private Object[] allMocks = new Object[] { messageMapper, message, ftpClient, ftpClientPool };
|
||||
|
||||
@Before
|
||||
public void intitializeSubject() {
|
||||
this.ftpTarget = new FtpTarget(messageMapper, ftpClientPool);
|
||||
}
|
||||
|
||||
// Tests
|
||||
@Test
|
||||
public void send() throws Exception {
|
||||
expect(messageMapper.mapMessage(message)).andReturn(File.createTempFile("test", ".tmp"));
|
||||
expect(ftpClient.storeFile(isA(String.class), isA(FileInputStream.class))).andReturn(true);
|
||||
replay(allMocks);
|
||||
boolean sent = ftpTarget.send(message);
|
||||
assertTrue(sent);
|
||||
verify(allMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sendFailed_negative() throws Exception {
|
||||
expect(messageMapper.mapMessage(message)).andReturn(File.createTempFile("test", ".tmp"));
|
||||
expect(ftpClient.storeFile(isA(String.class), isA(FileInputStream.class))).andReturn(false);
|
||||
replay(allMocks);
|
||||
boolean sent = ftpTarget.send(message);
|
||||
assertFalse(sent);
|
||||
verify(allMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sendFailed_() throws Exception {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp;
|
||||
|
||||
import static junit.framework.Assert.assertEquals;
|
||||
import static junit.framework.Assert.assertSame;
|
||||
import static junit.framework.Assert.assertTrue;
|
||||
import static org.easymock.EasyMock.expect;
|
||||
import static org.easymock.classextension.EasyMock.createMock;
|
||||
import static org.easymock.classextension.EasyMock.createNiceMock;
|
||||
import static org.easymock.classextension.EasyMock.replay;
|
||||
import static org.easymock.classextension.EasyMock.verify;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.net.ftp.FTPClient;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
public class QueuedFTPClientPoolTest {
|
||||
|
||||
private QueuedFTPClientPool pool;
|
||||
|
||||
private FTPClientFactory factoryMock = createMock(FTPClientFactory.class);
|
||||
|
||||
private Object[] allMocks = new Object[] { factoryMock };
|
||||
|
||||
|
||||
@Before
|
||||
public void initializeSubject() throws Exception {
|
||||
this.pool = new QueuedFTPClientPool(5);
|
||||
pool.setFactory(factoryMock);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void get() throws Exception {
|
||||
FTPClient expectedClient = new FTPClient();
|
||||
expect(factoryMock.getClient()).andReturn(expectedClient);
|
||||
replay(allMocks);
|
||||
FTPClient client = pool.getClient();
|
||||
assertEquals(expectedClient, client);
|
||||
verify(allMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getMultipleGet() throws Exception {
|
||||
FTPClient[] expectedClients = new FTPClient[] { mockedFTPClient(), mockedFTPClient(),
|
||||
mockedFTPClient(), mockedFTPClient(), mockedFTPClient(), mockedFTPClient() };
|
||||
for (FTPClient client : expectedClients) {
|
||||
expect(factoryMock.getClient()).andReturn(client);
|
||||
}
|
||||
replay(allMocks);
|
||||
for (int i = 0; i < 6; i++) {
|
||||
assertSame(expectedClients[i], pool.getClient());
|
||||
}
|
||||
verify(allMocks);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getMultipleGetReleaseGet() throws Exception {
|
||||
FTPClient[] expectedClients = new FTPClient[] { mockedFTPClient(), mockedFTPClient(),
|
||||
mockedFTPClient(), mockedFTPClient(), mockedFTPClient() };
|
||||
for (FTPClient client : expectedClients) {
|
||||
expect(factoryMock.getClient()).andReturn(client);
|
||||
}
|
||||
replay(allMocks);
|
||||
List<FTPClient> fromPool = new ArrayList<FTPClient>();
|
||||
for (int i = 0; i < 5; i++) {
|
||||
fromPool.add(pool.getClient());
|
||||
}
|
||||
for (FTPClient client2 : fromPool) {
|
||||
pool.releaseClient(client2);
|
||||
}
|
||||
for (int i = 0; i < 5; i++) {
|
||||
FTPClient client = pool.getClient();
|
||||
boolean removed = fromPool.remove(client);
|
||||
assertTrue("Failed on element " + i, removed);
|
||||
}
|
||||
verify(allMocks);
|
||||
}
|
||||
|
||||
|
||||
private FTPClient mockedFTPClient() throws Exception {
|
||||
FTPClient mock = createNiceMock(FTPClient.class);
|
||||
expect(mock.isConnected()).andReturn(true).anyTimes();
|
||||
expect(mock.sendNoOp()).andReturn(true).anyTimes();
|
||||
replay(mock);
|
||||
return mock;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp.config;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
import org.springframework.integration.message.GenericMessage;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageCreator;
|
||||
|
||||
/**
|
||||
* @author Marius Bogoevici
|
||||
*/
|
||||
public class CustomMessageCreator implements MessageCreator<File, String>{
|
||||
|
||||
public Message<String> createMessage(File object) {
|
||||
return new GenericMessage<String> (object.getAbsolutePath());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
package org.springframework.integration.adapter.ftp.config;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Ignore;
|
||||
import org.junit.Test;
|
||||
import org.springframework.context.ApplicationContext;
|
||||
import org.springframework.context.support.ClassPathXmlApplicationContext;
|
||||
import org.springframework.integration.adapter.ftp.FtpSource;
|
||||
import org.springframework.integration.adapter.ftp.QueuedFTPClientPool;
|
||||
import org.springframework.integration.channel.ChannelRegistry;
|
||||
import org.springframework.integration.channel.PollableChannel;
|
||||
import org.springframework.integration.config.MessageBusParser;
|
||||
import org.springframework.integration.message.GenericMessage;
|
||||
import org.springframework.integration.message.Message;
|
||||
import org.springframework.integration.message.MessageCreator;
|
||||
|
||||
/**
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
/*
|
||||
* These tests assume you have a local ftp server running. The whole class
|
||||
* should be disabled and only run when you have started your ftp server and are
|
||||
* in need of experimenting.
|
||||
*
|
||||
* To pass the test you should have an ftp server running at localhost that
|
||||
* accepts a login for ftp-user/kaas and has a remote directory ftp-test with at
|
||||
* least one file in it. Nothing is stopping you from changing the code to your
|
||||
* needs of course, this is just a starting point for local testing.
|
||||
*/
|
||||
// ftp server dependency. comment away Ignore if you want to run this
|
||||
@Ignore
|
||||
public class FtpSourceIntegrationTests {
|
||||
|
||||
private FtpSource ftpSource;
|
||||
|
||||
private MessageCreator<List<File>, List<File>> messageCreator = new MessageCreator<List<File>, List<File>>() {
|
||||
|
||||
public Message<List<File>> createMessage(List<File> object) {
|
||||
return new GenericMessage<List<File>>(object);
|
||||
}
|
||||
};
|
||||
|
||||
private static File localWorkDir;
|
||||
|
||||
@BeforeClass
|
||||
public static void initializeEnvironment() {
|
||||
localWorkDir = new File(System.getProperty("java.io.tmpdir") + "/" + FtpSourceIntegrationTests.class.getName());
|
||||
localWorkDir.mkdir();
|
||||
}
|
||||
|
||||
@Before
|
||||
public void initializeFtpSource() throws Exception {
|
||||
QueuedFTPClientPool queuedFTPClientPool = new QueuedFTPClientPool();
|
||||
ftpSource = new FtpSource(messageCreator, queuedFTPClientPool);
|
||||
queuedFTPClientPool.setHost("localhost");
|
||||
queuedFTPClientPool.setUsername("ftp-user");
|
||||
queuedFTPClientPool.setPassword("kaas");
|
||||
ftpSource.setLocalWorkingDirectory(localWorkDir);
|
||||
queuedFTPClientPool.setRemoteWorkingDirectory("ftp-test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void receive() {
|
||||
Message<List<File>> received = ftpSource.receive();
|
||||
assertTrue(received.getPayload().iterator().next().exists());
|
||||
}
|
||||
|
||||
@Test public void withChannelAdapter() {
|
||||
ApplicationContext context = new ClassPathXmlApplicationContext("ftpSourceWithChannelAdapter.xml", this.getClass());
|
||||
ChannelRegistry channelRegistry = (ChannelRegistry) context.getBean(MessageBusParser.MESSAGE_BUS_BEAN_NAME);
|
||||
PollableChannel input = (PollableChannel) channelRegistry.lookupChannel("output");
|
||||
List<File> files = new ArrayList<File>();
|
||||
files.add((File) input.receive().getPayload());
|
||||
files.add((File) input.receive().getPayload());
|
||||
assertTrue(files.containsAll(Arrays.asList(new File("file1"), new File("file2"))));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.springframework.integration.adapter.ftp.config;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import org.springframework.beans.DirectFieldAccessor;
|
||||
import org.springframework.context.ApplicationContext;
|
||||
import org.springframework.context.support.ClassPathXmlApplicationContext;
|
||||
import org.springframework.integration.adapter.ftp.FtpSource;
|
||||
import org.springframework.integration.message.DefaultMessageCreator;
|
||||
|
||||
/**
|
||||
* @author Mark Fisher
|
||||
* @author Marius Bogoevici
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
public class FtpSourceParserTests {
|
||||
|
||||
@Test
|
||||
public void testFtpSourceAdapterParser() {
|
||||
ApplicationContext context = new ClassPathXmlApplicationContext("ftpSourceParserTests.xml", this.getClass());
|
||||
FtpSource ftpSource = (FtpSource) context.getBean("ftpSourceDefault");
|
||||
DirectFieldAccessor sourceAccessor = new DirectFieldAccessor(ftpSource);
|
||||
DirectFieldAccessor accessor = new DirectFieldAccessor(sourceAccessor.getPropertyValue("clientPool"));
|
||||
assertEquals("testHost", accessor.getPropertyValue("host"));
|
||||
assertEquals(2121, accessor.getPropertyValue("port"));
|
||||
assertEquals(new File("/local"), sourceAccessor.getPropertyValue("localWorkingDirectory"));
|
||||
assertEquals("/remote", accessor.getPropertyValue("remoteWorkingDirectory"));
|
||||
assertEquals("testUser", accessor.getPropertyValue("username"));
|
||||
assertEquals("testPassword", accessor.getPropertyValue("password"));
|
||||
Object messageCreator = sourceAccessor.getPropertyValue("messageCreator");
|
||||
assertTrue(messageCreator instanceof DefaultMessageCreator);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFtpSourceCustomType() {
|
||||
ApplicationContext context = new ClassPathXmlApplicationContext("ftpSourceParserTests.xml", this.getClass());
|
||||
FtpSource ftpSource = (FtpSource) context.getBean("ftpSourceCustom");
|
||||
DirectFieldAccessor sourceAccessor = new DirectFieldAccessor(ftpSource);
|
||||
DirectFieldAccessor accessor = new DirectFieldAccessor(sourceAccessor.getPropertyValue("clientPool"));
|
||||
assertEquals("testHost", accessor.getPropertyValue("host"));
|
||||
assertEquals(2121, accessor.getPropertyValue("port"));
|
||||
assertEquals(new File("/local"), sourceAccessor.getPropertyValue("localWorkingDirectory"));
|
||||
assertEquals("/remote", accessor.getPropertyValue("remoteWorkingDirectory"));
|
||||
assertEquals("testUser", accessor.getPropertyValue("username"));
|
||||
assertEquals("testPassword", accessor.getPropertyValue("password"));
|
||||
Object messageCreator = sourceAccessor.getPropertyValue("messageCreator");
|
||||
assertTrue(messageCreator instanceof CustomMessageCreator);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
/*
|
||||
* Copyright 2002-2008 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.integration.adapter.ftp.config;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FilenameFilter;
|
||||
|
||||
import org.apache.oro.io.Perl5FilenameFilter;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Before;
|
||||
import org.junit.Ignore;
|
||||
import org.junit.Test;
|
||||
import org.springframework.integration.adapter.ftp.FtpTarget;
|
||||
import org.springframework.integration.adapter.ftp.QueuedFTPClientPool;
|
||||
import org.springframework.integration.message.DefaultMessageMapper;
|
||||
import org.springframework.integration.message.GenericMessage;
|
||||
|
||||
/**
|
||||
* @author Iwein Fuld
|
||||
*/
|
||||
@Ignore
|
||||
public class FtpTargetIntegrationTest {
|
||||
|
||||
private FtpTarget ftpTarget;
|
||||
|
||||
@Before
|
||||
public void initFtpTarget() {
|
||||
QueuedFTPClientPool clientPool = new QueuedFTPClientPool();
|
||||
clientPool.setHost("localhost");
|
||||
clientPool.setUsername("ftp-user");
|
||||
clientPool.setPassword("kaas");
|
||||
clientPool.setRemoteWorkingDirectory("ftp-test");
|
||||
ftpTarget = new FtpTarget(new DefaultMessageMapper<File>(), clientPool);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void send() throws Exception {
|
||||
File file = File.createTempFile("test", "");
|
||||
assertTrue(ftpTarget.send(new GenericMessage<File>(file)));
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void deleteTestFiles() {
|
||||
File tmpDir = new File(System.getProperty("java.io.tmpdir"));
|
||||
File[] files = tmpDir.listFiles((FilenameFilter) new Perl5FilenameFilter("test\\d"));
|
||||
for (File file : files) {
|
||||
file.delete();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<beans xmlns="http://www.springframework.org/schema/beans"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xmlns:si="http://www.springframework.org/schema/integration"
|
||||
xsi:schemaLocation="http://www.springframework.org/schema/beans
|
||||
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
|
||||
http://www.springframework.org/schema/integration
|
||||
http://www.springframework.org/schema/integration/spring-integration-1.0.xsd">
|
||||
|
||||
<si:ftp-source id="ftpSourceDefault"
|
||||
host="testHost"
|
||||
port="2121"
|
||||
local-working-directory="/local"
|
||||
remote-working-directory="/remote"
|
||||
username="testUser"
|
||||
password="testPassword"/>
|
||||
|
||||
<si:ftp-source id="ftpSourceText"
|
||||
host="testHost"
|
||||
port="2121"
|
||||
local-working-directory="/local"
|
||||
remote-working-directory="/remote"
|
||||
username="testUser"
|
||||
password="testPassword"
|
||||
/>
|
||||
|
||||
<si:ftp-source id="ftpSourceBinary"
|
||||
host="testHost"
|
||||
port="2121"
|
||||
local-working-directory="/local"
|
||||
remote-working-directory="/remote"
|
||||
username="testUser"
|
||||
password="testPassword"
|
||||
/>
|
||||
|
||||
<si:ftp-source id="ftpSourceFile"
|
||||
host="testHost"
|
||||
port="2121"
|
||||
local-working-directory="/local"
|
||||
remote-working-directory="/remote"
|
||||
username="testUser"
|
||||
password="testPassword"
|
||||
/>
|
||||
|
||||
<si:ftp-source id="ftpSourceCustom"
|
||||
host="testHost"
|
||||
port="2121"
|
||||
local-working-directory="/local"
|
||||
remote-working-directory="/remote"
|
||||
username="testUser"
|
||||
password="testPassword"
|
||||
message-creator="customMessageCreator"/>
|
||||
|
||||
<bean id="customMessageCreator"
|
||||
class="org.springframework.integration.adapter.ftp.config.CustomMessageCreator"/>
|
||||
|
||||
</beans>
|
||||
@@ -1,36 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<beans xmlns="http://www.springframework.org/schema/beans"
|
||||
xmlns:si="http://www.springframework.org/schema/integration"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xmlns:p="http://www.springframework.org/schema/p"
|
||||
xsi:schemaLocation="
|
||||
http://www.springframework.org/schema/beans
|
||||
http://www.springframework.org/schema/beans/spring-beans.xsd
|
||||
http://www.springframework.org/schema/integration
|
||||
http://www.springframework.org/schema/integration/spring-integration-1.0.xsd">
|
||||
|
||||
<si:message-bus />
|
||||
|
||||
<bean id="ftpSource"
|
||||
class="org.springframework.integration.adapter.ftp.FtpSource">
|
||||
<constructor-arg>
|
||||
<bean
|
||||
class="org.springframework.integration.message.DefaultMessageCreator" />
|
||||
</constructor-arg>
|
||||
<constructor-arg>
|
||||
<bean
|
||||
class="org.springframework.integration.adapter.ftp.QueuedFTPClientPool"
|
||||
p:host="localhost" p:password="kaas" p:username="ftp-user"
|
||||
p:remoteWorkingDirectory="ftp-test" />
|
||||
</constructor-arg>
|
||||
</bean>
|
||||
|
||||
<si:channel-adapter id="input" source="ftpSource" />
|
||||
|
||||
<bean id="splitter"
|
||||
class="org.springframework.integration.adapter.ftp.config.CollectionSplitter" />
|
||||
<si:splitter output-channel="output" input-channel="input"
|
||||
ref="splitter" method="split" />
|
||||
|
||||
<si:channel id="output" />
|
||||
</beans>
|
||||
Reference in New Issue
Block a user