1 package org.apache.archiva.rest.services;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider;
23 import org.apache.archiva.admin.model.beans.ManagedRepository;
24 import org.apache.archiva.common.utils.FileUtil;
25 import org.apache.archiva.redback.rest.api.services.RedbackServiceException;
26 import org.apache.archiva.redback.rest.services.AbstractRestServicesTest;
27 import org.apache.archiva.rest.api.services.ArchivaAdministrationService;
28 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
29 import org.apache.archiva.rest.api.services.RedbackRuntimeConfigurationService;
30 import org.apache.archiva.rest.api.services.BrowseService;
31 import org.apache.archiva.rest.api.services.CommonServices;
32 import org.apache.archiva.rest.api.services.ManagedRepositoriesService;
33 import org.apache.archiva.rest.api.services.MergeRepositoriesService;
34 import org.apache.archiva.rest.api.services.NetworkProxyService;
35 import org.apache.archiva.rest.api.services.PingService;
36 import org.apache.archiva.rest.api.services.ProxyConnectorRuleService;
37 import org.apache.archiva.rest.api.services.ProxyConnectorService;
38 import org.apache.archiva.rest.api.services.RemoteRepositoriesService;
39 import org.apache.archiva.rest.api.services.RepositoriesService;
40 import org.apache.archiva.rest.api.services.RepositoryGroupService;
41 import org.apache.archiva.rest.api.services.SearchService;
42 import org.apache.archiva.security.common.ArchivaRoleConstants;
43 import org.apache.archiva.test.utils.ArchivaBlockJUnit4ClassRunner;
44 import org.apache.commons.io.FileUtils;
45 import org.apache.commons.lang.StringUtils;
46 import org.apache.cxf.jaxrs.client.JAXRSClientFactory;
47 import org.apache.cxf.jaxrs.client.WebClient;
48 import org.junit.Assume;
49 import org.junit.Before;
50 import org.junit.BeforeClass;
51 import org.junit.runner.RunWith;
52 import org.slf4j.LoggerFactory;
53
54 import javax.ws.rs.core.MediaType;
55 import java.io.File;
56 import java.io.IOException;
57 import java.util.Collections;
58 import java.util.Date;
59 import org.apache.archiva.rest.api.services.PluginsService;
60
61
62
63
64 @RunWith(ArchivaBlockJUnit4ClassRunner.class)
65 public abstract class AbstractArchivaRestTest
66 extends AbstractRestServicesTest
67 {
68
69
70
71 public static String guestAuthzHeader =
72 "Basic " + org.apache.cxf.common.util.Base64Utility.encode( ( "guest" + ":" ).getBytes() );
73
74
75
76
77
78
79
80 @BeforeClass
81 public static void chekRepo()
82 {
83 Assume.assumeTrue( !System.getProperty( "appserver.base" ).contains( " " ) );
84 LoggerFactory.getLogger( AbstractArchivaRestTest.class.getName() ).
85 error( "Rest services unit test must be run in a folder with no space" );
86
87
88
89 }
90
91 @Override
92 @Before
93 public void startServer()
94 throws Exception
95 {
96 File appServerBase = new File( System.getProperty( "appserver.base" ) );
97
98 removeAppsubFolder( appServerBase, "jcr" );
99 removeAppsubFolder( appServerBase, "conf" );
100 removeAppsubFolder( appServerBase, "data" );
101
102 super.startServer();
103 }
104
105 private void removeAppsubFolder( File appServerBase, String folder )
106 throws Exception
107 {
108 File directory = new File( appServerBase, folder );
109 if ( directory.exists() )
110 {
111 FileUtils.deleteDirectory( directory );
112 }
113 }
114
115 @Override
116 protected String getSpringConfigLocation()
117 {
118 return "classpath*:META-INF/spring-context.xml,classpath:META-INF/spring-context-test.xml";
119 }
120
121 @Override
122 protected String getRestServicesPath()
123 {
124 return "restServices";
125 }
126
127 protected RepositoriesService getRepositoriesService()
128 {
129 return getRepositoriesService( null );
130 }
131
132 protected <T> T getService( Class<T> clazz, String authzHeader )
133 {
134 T service = JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/", clazz,
135 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
136
137 if ( authzHeader != null )
138 {
139 WebClient.client( service ).header( "Authorization", authzHeader );
140 }
141 WebClient.client(service).header("Referer","http://localhost:"+port);
142 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 100000000 );
143 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
144 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
145 return service;
146 }
147
148 protected ProxyConnectorRuleService getProxyConnectorRuleService( String authzHeader )
149 {
150 return getService( ProxyConnectorRuleService.class, authzHeader );
151 }
152
153 protected MergeRepositoriesService getMergeRepositoriesService( String authzHeader )
154 {
155 return getService( MergeRepositoriesService.class, authzHeader );
156 }
157
158 protected RepositoriesService getRepositoriesService( String authzHeader )
159 {
160 return getService( RepositoriesService.class, authzHeader );
161
162 }
163
164 protected ManagedRepositoriesService getManagedRepositoriesService( String authzHeader )
165 {
166 return getService( ManagedRepositoriesService.class, authzHeader );
167 }
168
169 protected PingService getPingService()
170 {
171 return getService( PingService.class, null );
172 }
173
174 protected PluginsService getPluginsService()
175 {
176 PluginsService service = getService( PluginsService.class, null );
177 WebClient.client( service ).accept( MediaType.TEXT_PLAIN );
178 WebClient.client( service ).type( MediaType.TEXT_PLAIN );
179 return service;
180 }
181
182 protected RemoteRepositoriesService getRemoteRepositoriesService()
183 {
184 return getService( RemoteRepositoriesService.class, null );
185
186
187 }
188
189 protected RepositoryGroupService getRepositoryGroupService()
190 {
191 return JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
192 RepositoryGroupService.class,
193 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
194 }
195
196 protected ProxyConnectorService getProxyConnectorService()
197 {
198 ProxyConnectorService service =
199 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
200 ProxyConnectorService.class,
201 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
202
203 WebClient.client( service ).header( "Authorization", authorizationHeader );
204 WebClient.client(service).header("Referer","http://localhost:"+port);
205 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 300000 );
206 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
207 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
208 return service;
209 }
210
211 protected NetworkProxyService getNetworkProxyService()
212 {
213 NetworkProxyService service =
214 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
215 NetworkProxyService.class,
216 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
217
218 WebClient.client( service ).header( "Authorization", authorizationHeader );
219 WebClient.client(service).header("Referer","http://localhost:"+port);
220 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 300000 );
221 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
222 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
223 return service;
224 }
225
226 protected ArchivaAdministrationService getArchivaAdministrationService()
227 {
228 ArchivaAdministrationService service =
229 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
230 ArchivaAdministrationService.class,
231 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
232
233 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
234 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
235
236 WebClient.client( service ).header( "Authorization", authorizationHeader );
237 WebClient.client(service).header("Referer","http://localhost:"+port);
238
239 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 300000 );
240 return service;
241 }
242
243 protected RedbackRuntimeConfigurationService getRedbackRuntimeConfigurationService()
244 {
245 RedbackRuntimeConfigurationService service =
246 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
247 RedbackRuntimeConfigurationService.class,
248 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
249
250 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
251 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
252
253 WebClient.client( service ).header( "Authorization", authorizationHeader );
254 WebClient.client(service).header("Referer","http://localhost:"+port);
255 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 300000 );
256 return service;
257 }
258
259 protected BrowseService getBrowseService( String authzHeader, boolean useXml )
260 {
261
262 BrowseService service =
263 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
264 BrowseService.class,
265 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
266
267 if ( authzHeader != null )
268 {
269 WebClient.client( service ).header( "Authorization", authzHeader );
270 }
271
272 WebClient.client(service).header("Referer","http://localhost:"+port);
273
274 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 100000000 );
275 if ( useXml )
276 {
277 WebClient.client( service ).accept( MediaType.APPLICATION_XML_TYPE );
278 WebClient.client( service ).type( MediaType.APPLICATION_XML_TYPE );
279 }
280 else
281 {
282 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
283 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
284 }
285 return service;
286
287
288 }
289
290 protected SearchService getSearchService( String authzHeader )
291 {
292
293 SearchService service =
294 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
295 SearchService.class,
296 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
297
298 if ( authzHeader != null )
299 {
300 WebClient.client( service ).header( "Authorization", authzHeader );
301 }
302
303 WebClient.client(service).header("Referer","http://localhost:"+port);
304
305 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 100000000 );
306
307 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
308 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
309 return service;
310
311
312 }
313
314 protected CommonServices getCommonServices( String authzHeader )
315 {
316 CommonServices service =
317 JAXRSClientFactory.create( getBaseUrl() + "/" + getRestServicesPath() + "/archivaServices/",
318 CommonServices.class,
319 Collections.singletonList( new JacksonJaxbJsonProvider() ) );
320
321 if ( authzHeader != null )
322 {
323 WebClient.client( service ).header( "Authorization", authzHeader );
324 }
325 WebClient.client(service).header("Referer","http://localhost:"+port);
326 WebClient.getConfig( service ).getHttpConduit().getClient().setReceiveTimeout( 100000000 );
327 WebClient.client( service ).accept( MediaType.APPLICATION_JSON_TYPE );
328 WebClient.client( service ).type( MediaType.APPLICATION_JSON_TYPE );
329 return service;
330 }
331
332 protected ManagedRepository getTestManagedRepository()
333 {
334 String location = new File( FileUtil.getBasedir(), "target/test-repo" ).getAbsolutePath();
335 return new ManagedRepository( "TEST", "test", location, "default", true, true, false, "2 * * * * ?", null,
336 false, 2, 3, true, false, "my nice repo", false );
337
338 }
339
340 protected String getBaseUrl()
341 {
342 String baseUrlSysProps = System.getProperty( "archiva.baseRestUrl" );
343 return StringUtils.isBlank( baseUrlSysProps ) ? "http://localhost:" + port : baseUrlSysProps;
344 }
345
346
347
348
349
350 static final String TARGET_REPO_ID = "test-copy-target";
351
352 static final String SOURCE_REPO_ID = "test-origin-repo";
353
354 protected void initSourceTargetRepo()
355 throws Exception
356 {
357 File targetRepo = new File( "target/test-repo-copy" );
358 if ( targetRepo.exists() )
359 {
360 FileUtils.deleteDirectory( targetRepo );
361 }
362 assertFalse( targetRepo.exists() );
363 targetRepo.mkdirs();
364
365 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( TARGET_REPO_ID ) != null )
366 {
367 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( TARGET_REPO_ID, true );
368 assertNull( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( TARGET_REPO_ID ) );
369 }
370 ManagedRepository managedRepository = getTestManagedRepository();
371 managedRepository.setId( TARGET_REPO_ID );
372 managedRepository.setLocation( targetRepo.getCanonicalPath() );
373 managedRepository.setCronExpression( "* * * * * ?" );
374 getManagedRepositoriesService( authorizationHeader ).addManagedRepository( managedRepository );
375 assertNotNull( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( TARGET_REPO_ID ) );
376
377 File originRepo = new File( "target/test-origin-repo" );
378 if ( originRepo.exists() )
379 {
380 FileUtils.deleteDirectory( originRepo );
381 }
382 assertFalse( originRepo.exists() );
383 FileUtils.copyDirectory( new File( "src/test/repo-with-osgi" ), originRepo );
384
385 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( SOURCE_REPO_ID ) != null )
386 {
387 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( SOURCE_REPO_ID, true );
388 assertNull( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( SOURCE_REPO_ID ) );
389 }
390
391 managedRepository = getTestManagedRepository();
392 managedRepository.setId( SOURCE_REPO_ID );
393 managedRepository.setLocation( originRepo.getCanonicalPath() );
394
395 getManagedRepositoriesService( authorizationHeader ).addManagedRepository( managedRepository );
396 assertNotNull( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( SOURCE_REPO_ID ) );
397
398 getArchivaAdministrationService().enabledKnownContentConsumer( "create-missing-checksums" );
399 getArchivaAdministrationService().enabledKnownContentConsumer( "metadata-updater" );
400
401 }
402
403 protected void cleanRepos()
404 throws Exception
405 {
406
407 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( TARGET_REPO_ID ) != null )
408 {
409 try
410 {
411 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( TARGET_REPO_ID, true );
412 assertNull(
413 getManagedRepositoriesService( authorizationHeader ).getManagedRepository( TARGET_REPO_ID ) );
414 }
415 catch ( Exception e )
416 {
417 log.warn( "skip issue while cleaning test repository: this can cause test failure", e );
418 }
419 }
420 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( SOURCE_REPO_ID ) != null )
421 {
422 try
423 {
424 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( SOURCE_REPO_ID, true );
425 assertNull(
426 getManagedRepositoriesService( authorizationHeader ).getManagedRepository( SOURCE_REPO_ID ) );
427 }
428 catch ( Exception e )
429 {
430 log.warn( "skip issue while cleaning test repository: this can cause test failure", e );
431 }
432 }
433
434 }
435
436 protected void createAndIndexRepo( String testRepoId, String repoPath, boolean stageNeeded )
437 throws ArchivaRestServiceException, IOException, RedbackServiceException
438 {
439 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( testRepoId ) != null )
440 {
441 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( testRepoId, false );
442 }
443
444 ManagedRepository managedRepository = new ManagedRepository();
445 managedRepository.setId( testRepoId );
446 managedRepository.setName( "test repo" );
447
448 File badContent = new File( repoPath, "target" );
449 if ( badContent.exists() )
450 {
451 FileUtils.deleteDirectory( badContent );
452 }
453
454 File file = new File( repoPath );
455 if ( !file.isAbsolute() )
456 {
457 repoPath = getBasedir() + "/" + repoPath;
458 }
459
460 managedRepository.setLocation( new File( repoPath ).getPath() );
461 managedRepository.setIndexDirectory(
462 System.getProperty( "java.io.tmpdir" ) + "/target/.index-" + Long.toString( new Date().getTime() ) );
463
464 managedRepository.setStageRepoNeeded( stageNeeded );
465 managedRepository.setSnapshots( true );
466
467
468
469 ManagedRepositoriesService service = getManagedRepositoriesService( authorizationHeader );
470 service.addManagedRepository( managedRepository );
471
472 getRoleManagementService( authorizationHeader ).assignTemplatedRole(
473 ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, testRepoId, "admin" );
474
475 getRoleManagementService( authorizationHeader ).assignTemplatedRole(
476 ArchivaRoleConstants.TEMPLATE_REPOSITORY_OBSERVER, testRepoId, "guest" );
477 }
478
479 protected void scanRepo( String testRepoId )
480 throws ArchivaRestServiceException
481 {
482 getRepositoriesService( authorizationHeader ).scanRepositoryNow( testRepoId, true );
483 }
484
485 protected void createAndIndexRepo( String testRepoId, String repoPath )
486 throws Exception
487 {
488 createAndIndexRepo( testRepoId, repoPath, false );
489 scanRepo( testRepoId );
490 }
491
492 protected void createStagedNeededRepo( String testRepoId, String repoPath, boolean scan )
493 throws Exception
494 {
495 createAndIndexRepo( testRepoId, repoPath, true );
496 if ( scan )
497 {
498 scanRepo( testRepoId );
499 }
500
501 RepositoriesService repositoriesService = getRepositoriesService( authorizationHeader );
502 repositoriesService.scanRepositoryDirectoriesNow( testRepoId );
503 if ( scan )
504 {
505 repositoriesService.scanRepositoryNow( testRepoId + "-stage", true );
506 repositoriesService.scanRepositoryDirectoriesNow( testRepoId + "-stage" );
507 }
508 }
509
510
511 protected void deleteTestRepo( String id )
512 throws Exception
513 {
514 if ( getManagedRepositoriesService( authorizationHeader ).getManagedRepository( id ) != null )
515 {
516 getManagedRepositoriesService( authorizationHeader ).deleteManagedRepository( id, false );
517 }
518 }
519
520 public String getBasedir()
521 {
522 return System.getProperty( "basedir" );
523 }
524
525 protected void waitForScanToComplete( String repoId )
526 throws ArchivaRestServiceException, InterruptedException
527 {
528 while ( getRepositoriesService( authorizationHeader ).alreadyScanning( repoId ) ) {
529
530 Thread.sleep( 100 );
531 }
532 }
533 }