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
  33 public class AddLegacyArtifactPathActionTest
  34     extends TestCase
  35 {
  36     private static final String EMPTY_STRING = "";
  37
  38     // valid inputs
  39     private static final String LEGACY_ARTIFACT_PATH_PATH_VALID_INPUT = "-abcXYZ0129._/\\";
  40
  41     private static final String GROUP_ID_VALID_INPUT = "abcXYZ0129._-";
  42
  43     private static final String ARTIFACT_ID_VALID_INPUT = "abcXYZ0129._-";
  44
  45     private static final String VERSION_VALID_INPUT = "abcXYZ0129._-";
  46
  47     private static final String CLASSIFIER_VALID_INPUT = "abcXYZ0129._-";
  48
  49     private static final String TYPE_VALID_INPUT = "abcXYZ0129._-";
  50
  51     // invalid inputs
  52     private static final String LEGACY_ARTIFACT_PATH_PATH_INVALID_INPUT = "<> ~+[ ]'\"";
  53
  54     private static final String GROUP_ID_INVALID_INPUT = "<> \\/~+[ ]'\"";
  55
  56     private static final String ARTIFACT_ID_INVALID_INPUT = "<> \\/~+[ ]'\"";
  57
  58     private static final String VERSION_INVALID_INPUT = "<> \\/~+[ ]'\"";
  59
  60     private static final String CLASSIFIER_INVALID_INPUT = "<> \\/~+[ ]'\"";
  61
  62     private static final String TYPE_INVALID_INPUT = "<> \\/~+[ ]'\"";
  63
  64     // testing requisite
  65     private AddLegacyArtifactPathAction addLegacyArtifactPathAction;
  66
  67     private ActionValidatorManager actionValidatorManager;
  68
  69     @Override
  70     public void setUp()
  71         throws Exception
  72     {
  73         addLegacyArtifactPathAction = new AddLegacyArtifactPathAction();
  74
  75         DefaultActionValidatorManagerFactory factory = new DefaultActionValidatorManagerFactory();
  76
  77         actionValidatorManager = factory.createDefaultActionValidatorManager();
  78     }
  79
  80     public void testStruts2ValidationFrameworkWithNullInputs()
  81         throws Exception
  82     {
  83         // prep
  84         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( null );
  85         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath, null, null, null,
  86                                                    null, null );
  87
  88         // test
  89         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
  90
  91         // verify
  92         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
  93
  94         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
  95
  96         // make an expected field error object
  97         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
  98
  99         // populate
 100         List<String> expectedErrorMessages = new ArrayList<String>();
 101         expectedErrorMessages.add( "You must enter a legacy path." );
 102         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 103
 104         expectedErrorMessages = new ArrayList<String>();
 105         expectedErrorMessages.add( "You must enter a groupId." );
 106         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 107
 108         expectedErrorMessages = new ArrayList<String>();
 109         expectedErrorMessages.add( "You must enter an artifactId." );
 110         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 111
 112         expectedErrorMessages = new ArrayList<String>();
 113         expectedErrorMessages.add( "You must enter a version." );
 114         expectedFieldErrors.put( "version", expectedErrorMessages );
 115
 116         expectedErrorMessages = new ArrayList<String>();
 117         expectedErrorMessages.add( "You must enter a type." );
 118         expectedFieldErrors.put( "type", expectedErrorMessages );
 119
 120         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 121     }
 122
 123     public void testStruts2ValidationFrameworkWithBlankInputs()
 124         throws Exception
 125     {
 126         // prep
 127         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( EMPTY_STRING );
 128         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath, EMPTY_STRING,
 129                                                    EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING );
 130
 131         // test
 132         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 133
 134         // verify
 135         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
 136
 137         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
 138
 139         // make an expected field error object
 140         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
 141
 142         // populate
 143         List<String> expectedErrorMessages = new ArrayList<String>();
 144         expectedErrorMessages.add( "You must enter a legacy path." );
 145         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 146
 147         expectedErrorMessages = new ArrayList<String>();
 148         expectedErrorMessages.add( "You must enter a groupId." );
 149         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 150
 151         expectedErrorMessages = new ArrayList<String>();
 152         expectedErrorMessages.add( "You must enter an artifactId." );
 153         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 154
 155         expectedErrorMessages = new ArrayList<String>();
 156         expectedErrorMessages.add( "You must enter a version." );
 157         expectedFieldErrors.put( "version", expectedErrorMessages );
 158
 159         expectedErrorMessages = new ArrayList<String>();
 160         expectedErrorMessages.add( "You must enter a type." );
 161         expectedFieldErrors.put( "type", expectedErrorMessages );
 162
 163         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 164     }
 165
 166     public void testStruts2ValidationFrameworkWithInvalidInputs()
 167         throws Exception
 168     {
 169         // prep
 170         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( LEGACY_ARTIFACT_PATH_PATH_INVALID_INPUT );
 171         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath,
 172                                                    GROUP_ID_INVALID_INPUT, ARTIFACT_ID_INVALID_INPUT,
 173                                                    VERSION_INVALID_INPUT, CLASSIFIER_INVALID_INPUT,
 174                                                    TYPE_INVALID_INPUT );
 175
 176         // test
 177         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 178
 179         // verify
 180         assertTrue( addLegacyArtifactPathAction.hasFieldErrors() );
 181
 182         Map<String, List<String>> fieldErrors = addLegacyArtifactPathAction.getFieldErrors();
 183
 184         // make an expected field error object
 185         Map<String, List<String>> expectedFieldErrors = new HashMap<String, List<String>>();
 186
 187         // populate
 188         List<String> expectedErrorMessages = new ArrayList<String>();
 189         expectedErrorMessages.add(
 190             "Legacy path must only contain alphanumeric characters, forward-slashes(/), back-slashes(\\), underscores(_), dots(.), and dashes(-)." );
 191         expectedFieldErrors.put( "legacyArtifactPath.path", expectedErrorMessages );
 192
 193         expectedErrorMessages = new ArrayList<String>();
 194         expectedErrorMessages.add(
 195             "Group id must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 196         expectedFieldErrors.put( "groupId", expectedErrorMessages );
 197
 198         expectedErrorMessages = new ArrayList<String>();
 199         expectedErrorMessages.add(
 200             "Artifact id must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 201         expectedFieldErrors.put( "artifactId", expectedErrorMessages );
 202
 203         expectedErrorMessages = new ArrayList<String>();
 204         expectedErrorMessages.add(
 205             "Version must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 206         expectedFieldErrors.put( "version", expectedErrorMessages );
 207
 208         expectedErrorMessages = new ArrayList<String>();
 209         expectedErrorMessages.add(
 210             "Classifier must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 211         expectedFieldErrors.put( "classifier", expectedErrorMessages );
 212
 213         expectedErrorMessages = new ArrayList<String>();
 214         expectedErrorMessages.add(
 215             "Type must only contain alphanumeric characters, underscores(_), dots(.), and dashes(-)." );
 216         expectedFieldErrors.put( "type", expectedErrorMessages );
 217
 218         ValidatorUtil.assertFieldErrors( expectedFieldErrors, fieldErrors );
 219     }
 220
 221     public void testStruts2ValidationFrameworkWithValidInputs()
 222         throws Exception
 223     {
 224         // prep
 225         LegacyArtifactPath legacyArtifactPath = createLegacyArtifactPath( LEGACY_ARTIFACT_PATH_PATH_VALID_INPUT );
 226         populateAddLegacyArtifactPathActionFields( addLegacyArtifactPathAction, legacyArtifactPath,
 227                                                    GROUP_ID_VALID_INPUT, ARTIFACT_ID_VALID_INPUT, VERSION_VALID_INPUT,
 228                                                    CLASSIFIER_VALID_INPUT, TYPE_VALID_INPUT );
 229
 230         // test
 231         actionValidatorManager.validate( addLegacyArtifactPathAction, EMPTY_STRING );
 232
 233         // verify
 234         assertFalse( addLegacyArtifactPathAction.hasFieldErrors() );
 235     }
 236
 237     private LegacyArtifactPath createLegacyArtifactPath( String path )
 238     {
 239         LegacyArtifactPath legacyArtifactPath = new LegacyArtifactPath();
 240         legacyArtifactPath.setPath( path );
 241         return legacyArtifactPath;
 242     }
 243
 244     private void populateAddLegacyArtifactPathActionFields( AddLegacyArtifactPathAction addLegacyArtifactPathAction,
 245                                                             LegacyArtifactPath legacyArtifactPath, String groupId,
 246                                                             String artifactId, String version, String classifier,
 247                                                             String type )
 248     {
 249         addLegacyArtifactPathAction.setLegacyArtifactPath( legacyArtifactPath );
 250         addLegacyArtifactPathAction.setGroupId( groupId );
 251         addLegacyArtifactPathAction.setArtifactId( artifactId );
 252         addLegacyArtifactPathAction.setVersion( version );
 253         addLegacyArtifactPathAction.setClassifier( classifier );
 254         addLegacyArtifactPathAction.setType( type );
 255     }
 256 }