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

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