Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
net.thucydides.core.steps.SatisfyAnnotatedStepDescription Maven / Gradle / Ivy
/*
* Copyright © 2015 Tapack, and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* The Research Projects is dual-licensed under the GNU General Public
* License, version 2.0 (GPLv2) and the Tapack Commercial License.
*
* Solely for non-commercial purposes. A purpose is non-commercial only if
* it is in no manner primarily intended for or directed toward commercial
* advantage or private monetary compensation.
*
* This Tapack Software is supplied to you by Tapack in consideration of your
* agreement to the following terms, and your use, installation, modification
* or redistribution of this Tapack Software constitutes acceptance of these
* terms. If you do not agree with these terms, please do not use, install,
* modify or redistribute this Tapack Software.
*
* Neither the name, trademarks, service marks or logos of Tapack may be used
* to endorse or promote products derived from the Tapack Software without
* specific prior written permission from Tapack.
*
* The Tapack Software is provided by Tapack on an "AS IS" basis. TAPACK
* MAKES NO
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
* WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, REGARDING THE TAPACK SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
* COMBINATION WITH YOUR PRODUCTS.
*
* IN NO EVENT SHALL TAPACK BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION
* AND/OR DISTRIBUTION OF THE TAPACK SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER
* THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR
* OTHERWISE, EVEN IF TAPACK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* A copy of the GNU General Public License is included in the distribution in
* the file LICENSE and at
*
* http://www.gnu.org/licenses/gpl-2.0.html
*
* If you are using the Research Projects for commercial purposes, we
* encourage you to visit
*
* http://products.tapack.io/license
*
* for more details.
*
* This software or hardware and documentation may provide access to
* or information on content, products, and services from third parties.
* Tapack and its affiliates are not responsible for and expressly disclaim
* all warranties of any kind with respect to third-party content, products,
* and services. Tapack and its affiliates will not be responsible for any loss,
* costs, or damages incurred due to your access to or use of third-party
* content, products, or services. If a third-party content exists, the
* additional copyright notices and license terms applicable to portions of the
* software are set forth in the THIRD_PARTY_LICENSE_README file.
*
* Please contact Tapack or visit www.tapack.io if you need additional
* information or have any questions.
*/
package net.thucydides.core.steps;
import com.google.common.base.Optional;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
import net.thucydides.core.annotations.Step;
import net.thucydides.core.annotations.StepGroup;
import net.thucydides.core.annotations.TestsRequirement;
import net.thucydides.core.annotations.TestsRequirements;
import net.thucydides.core.annotations.Title;
import net.thucydides.core.reflection.MethodFinder;
import org.apache.commons.lang3.StringUtils;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import static net.thucydides.core.util.NameConverter.humanize;
/**
* Test steps and step groups can be described by various annotations.
*/
public final class SatisfyAnnotatedStepDescription {
private static final List VALID_STEP_ANNOTATIONS = ImmutableList
.of("Step", "Given", "When", "Then");
private final ExecutedStepDescription description;
public static SatisfyAnnotatedStepDescription from(final
ExecutedStepDescription description) {
return new SatisfyAnnotatedStepDescription(description);
}
private SatisfyAnnotatedStepDescription(final ExecutedStepDescription
description) {
this.description = description;
}
public List getAnnotatedRequirements() {
List requirements = new ArrayList();
Method testMethod = getTestMethod();
if (testMethod != null) {
addRequirementFrom(requirements, testMethod);
addMultipleRequirementsFrom(requirements, testMethod);
}
return requirements;
}
private void addMultipleRequirementsFrom(final List requirements,
final Method testMethod) {
TestsRequirements testRequirements = testMethod.getAnnotation
(TestsRequirements.class);
if (testRequirements != null) {
requirements.addAll(Arrays.asList(testRequirements.value()));
}
}
private void addRequirementFrom(final List requirements, final
Method testMethod) {
TestsRequirement testsRequirement = testMethod
.getAnnotation(TestsRequirement.class);
if (testsRequirement != null) {
requirements.add(testsRequirement.value());
}
}
public Method getTestMethod() {
if (getTestClass() != null) {
return methodCalled(withNoArguments(description.getName()),
getTestClass());
} else {
return null;
}
}
public Method getTestMethodIfPresent() {
return findMethodCalled(withNoArguments(description.getName()),
getTestClass());
}
private String withNoArguments(final String methodName) {
String unqualifiedName = unqualified(methodName);
return stripFrom(':', unqualifiedName);
}
private String stripFrom(char boundaryChar, String text) {
int boundaryPosition = text.indexOf(boundaryChar);
if (boundaryPosition > 0) {
return text.substring(0, boundaryPosition);
} else {
return text;
}
}
private String unqualified(String methodName) {
return StringUtils.stripStart(methodName, "[0123456789] ");
}
private Class getTestClass() {
return description.getStepClass();
}
private Method methodCalled(final String methodName, final Class
testClass) {
Method methodFound = findMethodCalled(methodName, testClass);
if (methodFound == null) {
throw new IllegalArgumentException("No test method called " +
methodName + " was found in " + testClass);
}
return methodFound;
}
private Method findMethodCalled(final String methodName, final Class
testClass) {
return MethodFinder.inClass(testClass).getMethodNamed(methodName);
}
public String getAnnotatedTitle() {
Method testMethod = getTestMethod();
Title title = testMethod.getAnnotation(Title.class);
if (title != null) {
return title.value();
}
return null;
}
private Optional getAnnotatedStepName() {
Optional stepAnnotatedName = getNameFromStepAnnotationIn
(getTestMethod());
if (stepAnnotatedName.isPresent()) {
return stepAnnotatedName;
} else {
return getCompatibleStepNameFrom(getTestMethod());
}
}
public static boolean isACompatibleStep(Annotation annotation) {
return VALID_STEP_ANNOTATIONS.contains(annotation.annotationType()
.getSimpleName());
}
private Optional getCompatibleStepNameFrom(Method testMethod) {
Annotation[] annotations = testMethod.getAnnotations();
for (Annotation annotation : annotations) {
if (isACompatibleStep(annotation)) {
try {
String annotationType = annotation.annotationType()
.getSimpleName();
String annotatedValue = (String) annotation.getClass()
.getMethod("value").invoke(annotation);
if (StringUtils.isEmpty(annotatedValue)) {
return Optional.absent();
} else {
return Optional.of(annotationType + " " + StringUtils
.uncapitalize(annotatedValue));
}
} catch (Exception ignoredException) {
}
}
}
return Optional.absent();
}
private Optional getNameFromStepAnnotationIn(final Method
testMethod) {
Step step = testMethod.getAnnotation(Step.class);
if ((step != null) && (!StringUtils.isEmpty(step.value()))) {
return Optional.of(step.value());
}
return Optional.absent();
}
public String getName() {
if (noClassIsDefined()) {
return description.getName();
} else if (isAGroup()) {
return groupName();
} else {
return stepName();
}
}
private boolean noClassIsDefined() {
return description.getStepClass() == null;
}
private String groupName() {
String annotatedGroupName = getGroupName();
if (!StringUtils.isEmpty(annotatedGroupName)) {
return annotatedGroupName;
} else {
return stepName();
}
}
private String stepName() {
String annotationTitle = getAnnotatedTitle();
if (!StringUtils.isEmpty(annotationTitle)) {
return annotationTitle;
}
Optional annotatedStepName = getAnnotatedStepName();
if (getAnnotatedStepName().isPresent() && (StringUtils.isNotEmpty
(annotatedStepName.get()))) {
return annotatedStepNameWithParameters(annotatedStepName.get());
}
return humanize(description.getName());
}
private String annotatedStepNameWithParameters(String annotatedStepTemplate) {
String annotatedStepName = annotatedStepTemplate;
Iterable parameters = getParamatersFrom(description.getName());
for (String parameter : parameters) {
annotatedStepName = annotatedStepName.replaceFirst("\\$\\w*",
Matcher.quoteReplacement(parameter));
}
return annotatedStepName;
}
private Iterable getParamatersFrom(String name) {
String parameters = StringUtils.substringAfter(name, ":");
return Splitter.onPattern(",(?= <)").trimResults().split(parameters);
}
public boolean isAGroup() {
Method testMethod = getTestMethodIfPresent();
if (testMethod != null) {
StepGroup testGroup = testMethod.getAnnotation(StepGroup.class);
return (testGroup != null);
} else {
return false;
}
}
private String getGroupName() {
Method testMethod = getTestMethodIfPresent();
StepGroup testGroup = testMethod.getAnnotation(StepGroup.class);
return testGroup.value();
}
public boolean isPending() {
Method testMethod = getTestMethodIfPresent();
return testMethod != null && TestStatus.of(testMethod).isPending();
}
public boolean isIgnored() {
Method testMethod = getTestMethodIfPresent();
return testMethod != null && TestStatus.of(testMethod).isIgnored();
}
public boolean isFluent() {
if (description.getTestMethod() != null) {
Step step = description.getTestMethod().getAnnotation(Step.class);
return ((step != null) && (step.fluent()));
}
return false;
}
}
