View Javadoc

1   /*
2    * #%L
3    * Bitrepository Reference Pillar
4    * 
5    * $Id: ReplaceFileOnReferencePillarTest.java 589 2011-12-01 15:34:42Z jolf $
6    * $HeadURL: https://sbforge.org/svn/bitrepository/bitrepository-reference/trunk/bitrepository-reference-pillar/src/test/java/org/bitrepository/pillar/ReplaceFileOnReferencePillarTest.java $
7    * %%
8    * Copyright (C) 2010 - 2011 The State and University Library, The Royal Library and The State Archives, Denmark
9    * %%
10   * This program is free software: you can redistribute it and/or modify
11   * it under the terms of the GNU Lesser General Public License as 
12   * published by the Free Software Foundation, either version 2.1 of the 
13   * License, or (at your option) any later version.
14   * 
15   * This program is distributed in the hope that it will be useful,
16   * but WITHOUT ANY WARRANTY; without even the implied warranty of
17   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18   * GNU General Lesser Public License for more details.
19   * 
20   * You should have received a copy of the GNU General Lesser Public 
21   * License along with this program.  If not, see
22   * <http://www.gnu.org/licenses/lgpl-2.1.html>.
23   * #L%
24   */
25  package org.bitrepository.pillar.referencepillar;
26  
27  import java.util.Date;
28  import org.bitrepository.bitrepositoryelements.ChecksumDataForFileTYPE;
29  import org.bitrepository.bitrepositoryelements.ChecksumSpecTYPE;
30  import org.bitrepository.bitrepositoryelements.ChecksumType;
31  import org.bitrepository.bitrepositoryelements.ResponseCode;
32  import org.bitrepository.bitrepositorymessages.IdentifyPillarsForReplaceFileRequest;
33  import org.bitrepository.bitrepositorymessages.IdentifyPillarsForReplaceFileResponse;
34  import org.bitrepository.bitrepositorymessages.ReplaceFileFinalResponse;
35  import org.bitrepository.bitrepositorymessages.ReplaceFileProgressResponse;
36  import org.bitrepository.bitrepositorymessages.ReplaceFileRequest;
37  import org.bitrepository.common.utils.Base16Utils;
38  import org.bitrepository.common.utils.CalendarUtils;
39  import org.bitrepository.common.utils.TestFileHelper;
40  import org.bitrepository.pillar.messagefactories.ReplaceFileMessageFactory;
41  import org.testng.Assert;
42  import org.testng.annotations.BeforeClass;
43  import org.testng.annotations.Test;
44  
45  /**
46   * Tests the ReplaceFile functionality on the ReferencePillar.
47   */
48  public class ReplaceFileOnReferencePillarTest extends ReferencePillarTest {
49      private ReplaceFileMessageFactory msgFactory;
50      private final Long FILE_SIZE = 1L;
51      ChecksumDataForFileTYPE replaceCsData;
52      ChecksumDataForFileTYPE csData;
53      ChecksumSpecTYPE csSpec;
54  
55      @Override
56      public void initializeCUT() {
57          super.initializeCUT();
58          msgFactory = new ReplaceFileMessageFactory(collectionID, settingsForTestClient, getPillarID(),
59                  pillarDestinationId);
60  
61          csSpec = TestFileHelper.getDefaultFileChecksum().getChecksumSpec();
62          replaceCsData = TestFileHelper.getDefaultFileChecksum();
63  
64          csData = new ChecksumDataForFileTYPE();
65          csData.setCalculationTimestamp(CalendarUtils.getEpoch());
66          csData.setChecksumSpec(csSpec);
67          csData.setChecksumValue(Base16Utils.encodeBase16(EMPTY_FILE_CHECKSUM));
68      }
69  
70      @BeforeClass (alwaysRun=true)
71      public void initialiseReplaceFileClass() throws Exception {
72          httpServer.uploadFile(TestFileHelper.getDefaultFile(), TestFileHelper.DEFAULT_FILE_ID);
73      }
74  
75      
76      @Test( groups = {"regressiontest", "pillartest"})
77      public void referencePillarReplaceTestSuccessCase() throws Exception {
78          addDescription("Tests the replace functionality of the reference pillar for the successful scenario.");
79          addStep("Setting up the variables for the test.", "Should be instantiated.");
80  
81          addStep("Create and send a identify message to the pillar.", "Should be received and handled by the pillar.");
82          IdentifyPillarsForReplaceFileRequest identifyRequest = msgFactory.createIdentifyPillarsForReplaceFileRequest(
83                  DEFAULT_FILE_ID, FILE_SIZE);
84          messageBus.sendMessage(identifyRequest);
85          
86          addStep("Retrieve and validate the response getPillarID() the pillar.", "The pillar should make a response.");
87          IdentifyPillarsForReplaceFileResponse receivedIdentifyResponse = clientReceiver.waitForMessage(
88                  IdentifyPillarsForReplaceFileResponse.class);
89          Assert.assertEquals(receivedIdentifyResponse.getCorrelationID(), identifyRequest.getCorrelationID());
90          Assert.assertEquals(receivedIdentifyResponse.getFileID(), DEFAULT_FILE_ID);
91          Assert.assertEquals(receivedIdentifyResponse.getFrom(), getPillarID());
92          Assert.assertEquals(receivedIdentifyResponse.getPillarID(), getPillarID());
93          Assert.assertEquals(receivedIdentifyResponse.getReplyTo(), pillarDestinationId);
94          Assert.assertEquals(receivedIdentifyResponse.getResponseInfo().getResponseCode(), 
95                  ResponseCode.IDENTIFICATION_POSITIVE);
96          
97          addStep("Create and send the actual Replace message to the pillar.", 
98                  "Should be received and handled by the pillar.");
99          ReplaceFileRequest replaceRequest = msgFactory.createReplaceFileRequest(csData, replaceCsData, 
100                 csSpec, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE);
101         replaceRequest.setCorrelationID(identifyRequest.getCorrelationID());
102         messageBus.sendMessage(replaceRequest);
103         
104         addStep("Retrieve the ProgressResponse for the replace request", "The replace response should be sent by the pillar.");
105         ReplaceFileProgressResponse progressResponse = clientReceiver.waitForMessage(ReplaceFileProgressResponse.class);
106         Assert.assertEquals(progressResponse.getCorrelationID(), identifyRequest.getCorrelationID());
107         Assert.assertEquals(progressResponse.getFileID(), DEFAULT_FILE_ID);
108         Assert.assertEquals(progressResponse.getFrom(), getPillarID());
109         Assert.assertEquals(progressResponse.getPillarID(), getPillarID());
110         Assert.assertEquals(progressResponse.getReplyTo(), pillarDestinationId);
111         Assert.assertEquals(progressResponse.getResponseInfo().getResponseCode(), 
112                 ResponseCode.OPERATION_ACCEPTED_PROGRESS);
113         
114         addStep("Retrieve the FinalResponse for the replace request", "The replace response should be sent by the pillar.");
115         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
116         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), ResponseCode.
117                 OPERATION_COMPLETED);
118         
119         Assert.assertNotNull(finalResponse);
120         Assert.assertEquals(finalResponse.getCorrelationID(), replaceRequest.getCorrelationID());
121         Assert.assertEquals(finalResponse.getFileID(), DEFAULT_FILE_ID);
122         Assert.assertEquals(finalResponse.getFrom(), getPillarID());
123         Assert.assertEquals(finalResponse.getPillarID(), getPillarID());
124         Assert.assertEquals(finalResponse.getReplyTo(), pillarDestinationId);
125         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(),
126                 ResponseCode.OPERATION_COMPLETED);
127         
128         // validating the checksum
129         Assert.assertEquals(finalResponse.getFileID(), DEFAULT_FILE_ID, "The FileID of this test.");
130         Assert.assertNotNull(finalResponse.getChecksumDataForNewFile(), "The results should contain a ");
131         ChecksumDataForFileTYPE responseChecksumDataForOldFile = finalResponse.getChecksumDataForExistingFile();
132         Assert.assertNotNull(responseChecksumDataForOldFile.getChecksumSpec());
133         Assert.assertEquals(responseChecksumDataForOldFile.getChecksumSpec(), replaceRequest.getChecksumRequestForNewFile(), 
134                 "Should return the same type of checksum as requested.");
135         Assert.assertEquals(Base16Utils.decodeBase16(responseChecksumDataForOldFile.getChecksumValue()), 
136                 EMPTY_FILE_CHECKSUM);
137 
138         ChecksumDataForFileTYPE receivedChecksumData = finalResponse.getChecksumDataForNewFile();
139         Assert.assertNotNull(receivedChecksumData.getChecksumSpec());
140         Assert.assertEquals(receivedChecksumData.getChecksumSpec(), replaceRequest.getChecksumRequestForNewFile(), 
141                 "Should return the same type of checksum as requested.");
142         Assert.assertEquals(Base16Utils.decodeBase16(receivedChecksumData.getChecksumValue()), 
143                 Base16Utils.decodeBase16(replaceCsData.getChecksumValue()));
144     }
145     
146     @Test( groups = {"regressiontest", "pillartest"})
147     public void referencePillarReplaceFileTestFailedNoSuchFileDuringIdentify() throws Exception {
148         addDescription("Tests the ReplaceFile functionality of the checksum pillar for the scenario when the file does not exist.");
149 
150         addStep("Create and send the identify request message for a non existing file.",
151                 "Should be received and handled by the pillar.");
152         IdentifyPillarsForReplaceFileRequest identifyRequest =
153                 msgFactory.createIdentifyPillarsForReplaceFileRequest("NON-EXISTING-FILE", FILE_SIZE);
154         messageBus.sendMessage(identifyRequest);
155 
156         addStep("Retrieve and validate the response from the checksum pillar.",
157                 "The checksum pillar should make a response for 'FILE_NOT_FOUND'.");
158         IdentifyPillarsForReplaceFileResponse receivedIdentifyResponse =
159                 clientReceiver.waitForMessage(IdentifyPillarsForReplaceFileResponse.class);
160         Assert.assertEquals(receivedIdentifyResponse.getResponseInfo().getResponseCode(), 
161                 ResponseCode.FILE_NOT_FOUND_FAILURE);
162 
163         addStep("Validate the content of the cache", "Should not contain the checksum of the file");
164         Assert.assertEquals(archives.getFile(DEFAULT_FILE_ID, collectionID).length(), 0);
165     }
166     
167     @Test( groups = {"regressiontest", "pillartest"})
168     public void referencePillarReplaceFileTestFailedNoSuchFileDuringOperation() throws Exception {
169         addDescription("Tests the ReplaceFile functionality of the reference pillar for the scenario when the file " +
170                 "does not exist.");
171 
172         addStep("Send message for replacing the file", "Should send ");
173         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, replaceCsData, csSpec, csSpec,
174                 DEFAULT_DOWNLOAD_FILE_ADDRESS, "NoneExistingFile", FILE_SIZE));
175         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
176         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), ResponseCode.FILE_NOT_FOUND_FAILURE);
177         Assert.assertEquals(archives.getFile(DEFAULT_FILE_ID, collectionID).length(), 0);
178     }
179     
180     @Test( groups = {"regressiontest", "pillartest"})
181     public void referencePillarReplaceFileTestMissingExistingChecksumArgument() throws Exception {
182         addDescription("Tests that a missing 'ChecksumOnExistingFile' will not delete the file.");
183         Assert.assertTrue(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForDestructiveRequests());
184         Assert.assertTrue(archives.hasFile(DEFAULT_FILE_ID, collectionID));
185         messageBus.sendMessage(msgFactory.createReplaceFileRequest(null, replaceCsData, csSpec, csSpec,
186                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE));
187         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
188         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
189                 ResponseCode.EXISTING_FILE_CHECKSUM_FAILURE);
190     }
191     
192     @Test( groups = {"regressiontest", "pillartest"})
193     public void referencePillarReplaceFileTestBadExistingChecksumArgument() throws Exception {
194         addDescription("Tests that a wrong checksum in 'ChecksumOnExistingFile' will not delete the file.");
195         Assert.assertTrue(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForDestructiveRequests());
196 
197         ChecksumDataForFileTYPE badData = new ChecksumDataForFileTYPE();
198         badData.setCalculationTimestamp(CalendarUtils.getEpoch());
199         badData.setChecksumSpec(csSpec);
200         badData.setChecksumValue(Base16Utils.encodeBase16("baabbbaaabba"));
201 
202         messageBus.sendMessage(msgFactory.createReplaceFileRequest(badData, replaceCsData, csSpec, csSpec,
203                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE));
204         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
205         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
206                 ResponseCode.EXISTING_FILE_CHECKSUM_FAILURE);
207         Assert.assertEquals(archives.getFile(DEFAULT_FILE_ID, collectionID).length(), 0);
208     }
209 
210     @Test( groups = {"regressiontest", "pillartest"})
211     public void referencePillarReplaceFileTestAllowedMissingExistingChecksum() throws Exception {
212         addDescription("Tests that a missing 'ChecksumOnExistingFile' will replace the file, when it has been allowed "
213                 + "to perform destructive operations in the settings.");
214         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForDestructiveRequests(false);
215         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForDestructiveRequests());
216         messageBus.sendMessage(msgFactory.createReplaceFileRequest(null, replaceCsData, csSpec, csSpec,
217                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE));
218 
219         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
220         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
221                 ResponseCode.OPERATION_COMPLETED);
222     }
223     
224     @Test( groups = {"regressiontest", "pillartest"})
225     public void referencePillarReplaceFileTestMissingNewChecksumArgument() throws Exception {
226         addDescription("Tests that a missing 'ChecksumOnNewFile' will replace the file, if it is required but not given.");
227         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(true);
228         Assert.assertTrue(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
229         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, null, csSpec, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS,
230                 DEFAULT_FILE_ID, 1L));
231         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
232         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
233                 ResponseCode.NEW_FILE_CHECKSUM_FAILURE);
234     }
235 
236     @Test( groups = {"regressiontest", "pillartest"})
237     public void referencePillarReplaceFileTestBadNewChecksumArgument() throws Exception {
238         addDescription("Tests that a wrong checksum in 'ChecksumOnNewFile' will not delete the file.");
239         Assert.assertTrue(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForDestructiveRequests());
240 
241         ChecksumDataForFileTYPE badData = new ChecksumDataForFileTYPE();
242         badData.setCalculationTimestamp(CalendarUtils.getEpoch());
243         badData.setChecksumSpec(csSpec);
244         badData.setChecksumValue(Base16Utils.encodeBase16("baabbbaaabba"));
245 
246         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, badData, csSpec, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS,
247                 DEFAULT_FILE_ID, FILE_SIZE));
248         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
249         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
250                 ResponseCode.NEW_FILE_CHECKSUM_FAILURE);
251     }
252 
253     @Test( groups = {"regressiontest", "pillartest"})
254     public void referencePillarReplaceFileTestAllowedMissingNewChecksum() throws Exception {
255         addDescription("Tests that a missing 'ChecksumOnNewFile' will replace the file, if it is it not required nor given.");
256         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
257         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
258         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, null, csSpec, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS,
259                 DEFAULT_FILE_ID, FILE_SIZE));
260 
261         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
262         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
263                 ResponseCode.OPERATION_COMPLETED);
264     }
265  
266     @Test( groups = {"regressiontest", "pillartest"})
267     public void referencePillarReplaceFileTestBadExistingChecksumSpec() throws Exception {
268         addDescription("Tests that bad checksum spec in 'ChecksumOnExistingFile' will not replace the file.");
269         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
270         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
271 
272         ChecksumSpecTYPE badCsType = new ChecksumSpecTYPE();
273         badCsType.setChecksumType(ChecksumType.OTHER);
274         badCsType.setOtherChecksumType("NOT-EXISTING-TYPE");
275         ChecksumDataForFileTYPE badData = new ChecksumDataForFileTYPE();
276         badData.setCalculationTimestamp(CalendarUtils.getEpoch());
277         badData.setChecksumSpec(badCsType);
278         badData.setChecksumValue(Base16Utils.encodeBase16(EMPTY_FILE_CHECKSUM));
279 
280         messageBus.sendMessage(msgFactory.createReplaceFileRequest(badData, replaceCsData, csSpec, csSpec,
281                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE));
282 
283         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
284         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
285                 ResponseCode.REQUEST_NOT_UNDERSTOOD_FAILURE);
286     }
287     
288     @Test( groups = {"regressiontest", "pillartest"})
289     public void referencePillarReplaceFileTestBadNewChecksumSpec() throws Exception {
290         addDescription("Tests that bad checksum spec in 'ChecksumOnNewFile' will not replace the file.");
291         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
292         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
293 
294         ChecksumSpecTYPE badCsType = new ChecksumSpecTYPE();
295         badCsType.setChecksumType(ChecksumType.OTHER);
296         badCsType.setOtherChecksumType("NOT-EXISTING-TYPE");
297         ChecksumDataForFileTYPE badData = new ChecksumDataForFileTYPE();
298         badData.setCalculationTimestamp(CalendarUtils.getEpoch());
299         badData.setChecksumSpec(badCsType);
300         badData.setChecksumValue(Base16Utils.encodeBase16(EMPTY_FILE_CHECKSUM));
301 
302         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, badData, csSpec, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS,
303                 DEFAULT_FILE_ID, FILE_SIZE));
304 
305         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
306         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
307                 ResponseCode.REQUEST_NOT_UNDERSTOOD_FAILURE);
308     }
309     
310     @Test( groups = {"regressiontest", "pillartest"})
311     public void referencePillarReplaceFileTestBadExistingChecksumRequestSpec() throws Exception {
312         addDescription("Tests that bad checksum spec in 'ChecksumSpecForExistingFile' will not replace the file.");
313         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
314         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
315 
316         ChecksumSpecTYPE badCsType = new ChecksumSpecTYPE();
317         badCsType.setChecksumType(ChecksumType.OTHER);
318         badCsType.setOtherChecksumType("NOT-EXISTING-TYPE");
319 
320         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, replaceCsData, badCsType, csSpec, DEFAULT_DOWNLOAD_FILE_ADDRESS,
321                 DEFAULT_FILE_ID, FILE_SIZE));
322 
323         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
324         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
325                 ResponseCode.REQUEST_NOT_UNDERSTOOD_FAILURE);
326     }
327     
328     @Test( groups = {"regressiontest", "pillartest"})
329     public void referencePillarReplaceFileTestBadNewChecksumRequestSpec() throws Exception {
330         addDescription("Tests that bad checksum spec in 'ChecksumSpecForNewFile' will not replace the file.");
331         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
332         Assert.assertFalse(context.getSettings().getRepositorySettings().getProtocolSettings().isRequireChecksumForNewFileRequests());
333 
334         ChecksumSpecTYPE badCsType = new ChecksumSpecTYPE();
335         badCsType.setChecksumType(ChecksumType.OTHER);
336         badCsType.setOtherChecksumType("NOT-EXISTING-TYPE");
337 
338         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, replaceCsData, csSpec, badCsType,
339                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, FILE_SIZE));
340 
341         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
342         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
343                 ResponseCode.REQUEST_NOT_UNDERSTOOD_FAILURE);
344     }
345     
346     @Test( groups = {"regressiontest", "pillartest"})
347     public void referencePillarReplaceFileSuccessWithoutChecksums() throws Exception {
348         addDescription("Tests that it is possible to replace a file without any checksums if settings allows it.");
349         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForNewFileRequests(false);
350         context.getSettings().getRepositorySettings().getProtocolSettings().setRequireChecksumForDestructiveRequests(false);
351         messageBus.sendMessage(msgFactory.createReplaceFileRequest(null, null, null, null, DEFAULT_DOWNLOAD_FILE_ADDRESS,
352                 DEFAULT_FILE_ID, FILE_SIZE));
353 
354         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
355         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
356                 ResponseCode.OPERATION_COMPLETED);
357     }
358     
359     @Test( groups = {"regressiontest", "pillartest"})
360     public void referencePillarPutFileTestTooLargeFileInIdentification() throws Exception {
361         addDescription("Tests when the PutFile identification delivers a too large file.");
362         messageBus.sendMessage(msgFactory.createIdentifyPillarsForReplaceFileRequest(DEFAULT_FILE_ID, Long.MAX_VALUE));
363         IdentifyPillarsForReplaceFileResponse identifyResponse = clientReceiver.waitForMessage(IdentifyPillarsForReplaceFileResponse.class);
364         Assert.assertEquals(identifyResponse.getResponseInfo().getResponseCode(), 
365                 ResponseCode.FAILURE);
366     }
367     
368     @Test( groups = {"regressiontest", "pillartest"})
369     public void referencePillarPutFileTestNoFileSizeInIdentification() throws Exception {
370         addDescription("Tests when the PutFile identification does not deliver a file size. Should succeed");
371         messageBus.sendMessage(msgFactory.createIdentifyPillarsForReplaceFileRequest(DEFAULT_FILE_ID, null));
372         IdentifyPillarsForReplaceFileResponse identifyResponse = clientReceiver.waitForMessage(IdentifyPillarsForReplaceFileResponse.class);
373         Assert.assertEquals(identifyResponse.getResponseInfo().getResponseCode(), 
374                 ResponseCode.IDENTIFICATION_POSITIVE);
375     }
376     
377     @Test( groups = {"regressiontest", "pillartest"})
378     public void referencePillarPutFileTestTooLargeFileInOperation() throws Exception {
379         addDescription("Tests when the PutFile identification delivers a too large file.");
380         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, replaceCsData, csSpec, csSpec,
381                 DEFAULT_DOWNLOAD_FILE_ADDRESS, DEFAULT_FILE_ID, Long.MAX_VALUE));
382         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
383         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
384                 ResponseCode.FAILURE);
385     }
386     
387     @Test( groups = {"regressiontest", "pillartest"})
388     public void replacePillarReplaceFileBadURL() throws Exception {
389         addDescription("Tests the handling of a bad URL in the request.");
390         String fileAddress = "http://127.0.0.1/¾" + new Date().getTime();
391         messageBus.sendMessage(msgFactory.createReplaceFileRequest(csData, replaceCsData, csSpec, csSpec, fileAddress,
392                 DEFAULT_FILE_ID, FILE_SIZE));
393 
394         ReplaceFileFinalResponse finalResponse = clientReceiver.waitForMessage(ReplaceFileFinalResponse.class);
395         Assert.assertEquals(finalResponse.getResponseInfo().getResponseCode(), 
396                 ResponseCode.FILE_TRANSFER_FAILURE);
397     }
398 }