source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.action.admin.legacy;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.opensymphony.xwork2.validator.ActionValidatorManager;
  23 import junit.framework.TestCase;
  24 import org.apache.archiva.admin.model.beans.LegacyArtifactPath;
  25 import org.apache.archiva.web.validator.utils.ValidatorUtil;
  26 import org.apache.archiva.web.action.admin.repositories.DefaultActionValidatorManagerFactory;
  27
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import org.apache.archiva.test.ArchivaBlockJUnit4ClassRunner;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35 import org.junit.runner.RunWith;
  36 @RunWith( ArchivaBlockJUnit4ClassRunner.class )
  37 public class AddLegacyArtifactPathActionTest
  38     extends TestCase
  39 {
  40     private static final String EMPTY_STRING = "";
  41
  42     // valid inputs
  43     private static final String LEGACY_ARTIFACT_PATH_PATH_VALID_INPUT = "-abcXYZ0129._/\\";
  44
  45     private static final String GROUP_ID_VALID_INPUT = "abcXYZ0129._-";
  46
  47     private static final String ARTIFACT_ID_VALID_INPUT = "abcXYZ0129._-";
  48
  49     private static final String VERSION_VALID_INPUT = "abcXYZ0129._-";
  50
  51     private static final String CLASSIFIER_VALID_INPUT = "abcXYZ0129._-";
  52
  53     private static final String TYPE_VALID_INPUT = "abcXYZ0129._-";
  54
  55     // invalid inputs
  56     private static final String LEGACY_ARTIFACT_PATH_PATH_INVALID_INPUT = "<> ~+[ ]'\"";
  57
  58     private static final String GROUP_ID_INVALID_INPUT = "<> \\/~+[ ]'\"";
  59
  60     private static final String ARTIFACT_ID_INVALID_INPUT = "<> \\/~+[ ]'\"";
  61
  62     private static final String VERSION_INVALID_INPUT = "<> \\/~+[ ]'\"";
  63
  64     private static final String CLASSIFIER_INVALID_INPUT = "<> \\/~+[ ]'\"";
  65
  66     private static final String TYPE_INVALID_INPUT = "<> \\/~+[ ]'\"";
  67
  68     // testing requisite
  69     private AddLegacyArtifactPathAction addLegacyArtifactPathAction;
  70
  71     private ActionValidatorManager actionValidatorManager;
  72
  73     @Override
  74     @Before
  75     public void setUp()
  76         throws Exception
  77     {
  78         addLegacyArtifactPathAction = new AddLegacyArtifactPathAction();
  79
  80         DefaultActionValidatorManagerFactory factory = new DefaultActionValidatorManagerFactory();
  81
  82         actionValidatorManager = factory.createDefaultActionValidatorManager();
  83     }
  84
  85     @Test
  86     public void testStruts2ValidationFrameworkWithNullInputs()
  87         throws Exception
  88     {
  89         // prep
  90         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( null );
  91         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath, null, null, null,
  92                                                    null, null );
  93
  94         // test
  95         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
  96
  97         // verify
  98         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
  99
 100         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
 101
 102         // make an expected field error object
 103         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
 104
 105         // populate
 106         List<String> expectedErrorMessages = new ArrayList<String>();
 107         expectedErrorMessages.add( "You must enter a legacy path." );
 108         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 109
 110         expectedErrorMessages = new ArrayList<String>();
 111         expectedErrorMessages.add( "You must enter a groupId." );
 112         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 113
 114         expectedErrorMessages = new ArrayList<String>();
 115         expectedErrorMessages.add( "You must enter an artifactId." );
 116         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 117
 118         expectedErrorMessages = new ArrayList<String>();
 119         expectedErrorMessages.add( "You must enter a version." );
 120         expectedFieldErrors.put( "version", expectedErrorMessages );
 121
 122         expectedErrorMessages = new ArrayList<String>();
 123         expectedErrorMessages.add( "You must enter a type." );
 124         expectedFieldErrors.put( "type", expectedErrorMessages );
 125
 126         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 127     }
 128
 129     @Test
 130     public void testStruts2ValidationFrameworkWithBlankInputs()
 131         throws Exception
 132     {
 133         // prep
 134         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( EMPTY_STRING );
 135         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath, EMPTY_STRING,
 136                                                    EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING );
 137
 138         // test
 139         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 140
 141         // verify
 142         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
 143
 144         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
 145
 146         // make an expected field error object
 147         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
 148
 149         // populate
 150         List<String> expectedErrorMessages = new ArrayList<String>();
 151         expectedErrorMessages.add( "You must enter a legacy path." );
 152         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 153
 154         expectedErrorMessages = new ArrayList<String>();
 155         expectedErrorMessages.add( "You must enter a groupId." );
 156         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 157
 158         expectedErrorMessages = new ArrayList<String>();
 159         expectedErrorMessages.add( "You must enter an artifactId." );
 160         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 161
 162         expectedErrorMessages = new ArrayList<String>();
 163         expectedErrorMessages.add( "You must enter a version." );
 164         expectedFieldErrors.put( "version", expectedErrorMessages );
 165
 166         expectedErrorMessages = new ArrayList<String>();
 167         expectedErrorMessages.add( "You must enter a type." );
 168         expectedFieldErrors.put( "type", expectedErrorMessages );
 169
 170         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 171     }
 172
 173     @Test
 174     public void testStruts2ValidationFrameworkWithInvalidInputs()
 175         throws Exception
 176     {
 177         // prep
 178         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( LEGACY_ARTIFACT_PATH_PATH_INVALID_INPUT );
 179         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath,
 180                                                    GROUP_ID_INVALID_INPUT, ARTIFACT_ID_INVALID_INPUT,
 181                                                    VERSION_INVALID_INPUT, CLASSIFIER_INVALID_INPUT,
 182                                                    TYPE_INVALID_INPUT );
 183
 184         // test
 185         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 186
 187         // verify
 188         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
 189
 190         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
 191
 192         // make an expected field error object
 193         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
 194
 195         // populate
 196         List<String> expectedErrorMessages = new ArrayList<String>();
 197         expectedErrorMessages.add(
 198             "Legacy path must only contain alphanumeric characters, forward-slashes(/), back-slashes(\\), underscores(_), dots(.), and dashes(-)." );
 199         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 200
 201         expectedErrorMessages = new ArrayList<String>();
 202         expectedErrorMessages.add(
 203             "Group id must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 204         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 205
 206         expectedErrorMessages = new ArrayList<String>();
 207         expectedErrorMessages.add(
 208             "Artifact id must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 209         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 210
 211         expectedErrorMessages = new ArrayList<String>();
 212         expectedErrorMessages.add(
 213             "Version must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 214         expectedFieldErrors.put( "version", expectedErrorMessages );
 215
 216         expectedErrorMessages = new ArrayList<String>();
 217         expectedErrorMessages.add(
 218             "Classifier must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 219         expectedFieldErrors.put( "classifier", expectedErrorMessages );
 220
 221         expectedErrorMessages = new ArrayList<String>();
 222         expectedErrorMessages.add(
 223             "Type must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 224         expectedFieldErrors.put( "type", expectedErrorMessages );
 225
 226         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 227     }
 228
 229     @Test
 230     public void testStruts2ValidationFrameworkWithValidInputs()
 231         throws Exception
 232     {
 233         // prep
 234         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( LEGACY_ARTIFACT_PATH_PATH_VALID_INPUT );
 235         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath,
 236                                                    GROUP_ID_VALID_INPUT, ARTIFACT_ID_VALID_INPUT, VERSION_VALID_INPUT,
 237                                                    CLASSIFIER_VALID_INPUT, TYPE_VALID_INPUT );
 238
 239         // test
 240         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 241
 242         // verify
 243         assertFalse( addLegacyArtifactPathAction.hasFieldErrors() );
 244     }
 245
 246     private LegacyArtifactPath createLegacyArtifactPath( String path )
 247     {
 248         LegacyArtifactPath legacyArtifactPath = new LegacyArtifactPath();
 249         legacyArtifactPath.setPath( path );
 250         return legacyArtifactPath;
 251     }
 252
 253     private void populateAddLegacyArtifactPathActionFields( AddLegacyArtifactPathAction addLegacyArtifactPathAction,
 254                                                             LegacyArtifactPath legacyArtifactPath, String groupId,
 255                                                             String artifactId, String version, String classifier,
 256                                                             String type )
 257     {
 258         addLegacyArtifactPathAction.setLegacyArtifactPath( legacyArtifactPath );
 259         addLegacyArtifactPathAction.setGroupId( groupId );
 260         addLegacyArtifactPathAction.setArtifactId( artifactId );
 261         addLegacyArtifactPathAction.setVersion( version );
 262         addLegacyArtifactPathAction.setClassifier( classifier );
 263         addLegacyArtifactPathAction.setType( type );
 264     }
 265 }