@Override
public void addTagsToTestExecutions(
Collection<String> tags, Collection<TestExecution> testExecutions) {
for (TestExecution testExecutionItem : testExecutions) {
TestExecution testExecution = testExecutionDAO.get(testExecutionItem.getId());
if (testExecution == null) {
continue;
}
for (String tagName : tags) {
if (!testExecution.getTags().contains(tagName)) {
Tag tag = tagDAO.findByName(tagName);
if (tag == null) {
Tag newTag = new Tag();
newTag.setName(tagName);
tag = tagDAO.create(newTag);
}
Collection<TestExecution> tagTestExecutions = tag.getTestExecutions();
if (tagTestExecutions == null) {
tag.setTestExecutions(new ArrayList<>());
}
tag.getTestExecutions().add(testExecution);
testExecution.getTags().add(tag);
}
}
testExecutionDAO.update(testExecution);
}
}
@Override
@Secured
public void removeTestExecution(TestExecution testExecution) throws ServiceException {
TestExecution freshTestExecution = testExecutionDAO.get(testExecution.getId());
if (freshTestExecution == null) {
throw new ServiceException("serviceException.testExecutionNotFound", testExecution.getName());
}
for (TestExecutionParameter testExecutionParameter : freshTestExecution.getParameters()) {
testExecutionParameterDAO.remove(testExecutionParameter);
}
for (Value value : freshTestExecution.getValues()) {
for (ValueParameter valueParameter : value.getParameters()) {
valueParameterDAO.remove(valueParameter);
}
valueDAO.remove(value);
}
Iterator<TestExecutionAttachment> allTestExecutionAttachments =
freshTestExecution.getAttachments().iterator();
while (allTestExecutionAttachments.hasNext()) {
testExecutionAttachmentDAO.remove(allTestExecutionAttachments.next());
allTestExecutionAttachments.remove();
}
testExecutionDAO.remove(freshTestExecution);
}
@Override
@Secured
public TestExecution updateTestExecution(TestExecution testExecution) throws ServiceException {
TestExecution execEntity = testExecutionDAO.get(testExecution.getId());
if (execEntity == null) {
throw new ServiceException("serviceException.testExecutionNotFound", testExecution.getName());
}
// this is what can be updated here
execEntity.setName(testExecution.getName());
execEntity.setStarted(testExecution.getStarted());
execEntity.setComment(testExecution.getComment());
execEntity.setTags(new ArrayList<>());
for (Tag tag : testExecution.getTags()) {
Tag tagEntity = tagDAO.findByName(tag.getName());
if (tagEntity == null) {
Tag newTag = new Tag();
newTag.setName(tag.getName());
tagEntity = tagDAO.create(newTag);
}
Collection<TestExecution> tagTestExecutions = tagEntity.getTestExecutions();
if (tagTestExecutions == null) {
tagEntity.setTestExecutions(new ArrayList<>());
}
tagEntity.getTestExecutions().add(execEntity);
execEntity.getTags().add(tagEntity);
}
TestExecution execClone = cloneAndFetch(execEntity, true, true, true, true, true);
return execClone;
}
@Override
public List<TestExecution> getTestExecutions(List<String> tags, List<String> testUIDs) {
List<TestExecution> result = new ArrayList<TestExecution>();
for (String tag : tags) {
result.addAll(testExecutionDAO.getTestExecutions(Arrays.asList(tag.split(" ")), testUIDs));
}
return result;
}
@Override
public List<TestExecution> getAllFullTestExecutions() {
List<TestExecution> r = testExecutionDAO.getAll();
List<TestExecution> rcopy = new ArrayList<TestExecution>(r.size());
for (TestExecution exec : r) {
rcopy.add(getFullTestExecution(exec.getId()));
}
return rcopy;
}
@Override
public void removeTagsFromTestExecutions(
Collection<String> tags, Collection<TestExecution> testExecutions) {
for (TestExecution testExecutionItem : testExecutions) {
TestExecution testExecution = testExecutionDAO.get(testExecutionItem.getId());
if (testExecution == null) {
continue;
}
for (Tag tag : testExecution.getTags()) {
if (tags.contains(tag.getName())) {
testExecution.getTags().remove(tag);
}
}
testExecutionDAO.update(testExecution);
}
}
@Override
@Secured
public void removeParameter(TestExecutionParameter tep) throws ServiceException {
TestExecution exec = testExecutionDAO.get(tep.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.testExecutionNotFound", tep.getTestExecution().getName());
}
TestExecutionParameter tepRemove = testExecutionParameterDAO.get(tep.getId());
testExecutionParameterDAO.remove(tepRemove);
}
@Override
@Secured
public Long addAttachment(TestExecutionAttachment attachment) throws ServiceException {
TestExecution exec = testExecutionDAO.get(attachment.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.addAttachment.testExecutionNotFound",
attachment.getTestExecution().getName());
}
attachment.setTestExecution(exec);
TestExecutionAttachment newAttachment = testExecutionAttachmentDAO.create(attachment);
return newAttachment.getId();
}
private TestExecution cloneAndFetch(
TestExecution exec,
boolean fetchTest,
boolean fetchParameters,
boolean fetchTags,
boolean fetchValues,
boolean fetchAttachments) {
if (exec == null) {
return null;
}
TestExecution clone = exec.clone();
if (fetchTest) {
TestExecutionDAO.fetchTest(clone);
} else {
clone.setTest(null);
}
if (fetchParameters) {
TestExecutionDAO.fetchParameters(clone);
} else {
clone.setParameters(null);
}
if (fetchTags) {
TestExecutionDAO.fetchTags(clone);
} else {
clone.setTags(null);
}
if (fetchValues) {
TestExecutionDAO.fetchValues(clone);
} else {
clone.setValues(null);
}
if (fetchAttachments) {
TestExecutionDAO.fetchAttachments(clone);
} else {
clone.setAttachments(null);
}
return clone;
}
@Override
@Secured
public Value addValue(Value value) throws ServiceException {
TestExecution exec = testExecutionDAO.get(value.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.addValue.testExecutionNotFound", value.getTestExecution().getName());
}
Metric metric = null;
if (value.getMetric().getId() != null) {
metric = metricDAO.get(value.getMetric().getId());
} else {
List<Metric> metrics =
metricDAO.getMetricByNameAndGroup(
value.getMetric().getName(), exec.getTest().getGroupId());
if (metrics.size() > 0) {
metric = metricDAO.get(metrics.get(0).getId());
}
}
if (metric == null) {
throw new ServiceException("serviceException.metricNotFound", value.getMetric().getName());
}
value.setTestExecution(exec);
value.setMetric(metric);
// check if other values for given metric exist, if yes, we can only add one if both old and new
// one have at least one parameter
List<Value> existingValuesForMetric = valueDAO.find(exec.getId(), metric.getId());
if (!existingValuesForMetric.isEmpty()) {
for (Value v : existingValuesForMetric) {
if (!v.hasParameters()) {
throw new ServiceException("serviceException.unparametrizedMultiValue");
}
}
if (!value.hasParameters()) {
throw new ServiceException("serviceException.unparametrizedMultiValue");
}
}
Value freshValue = valueDAO.create(value);
Value freshValueClone = freshValue.clone();
List<ValueParameter> newParams = new ArrayList<ValueParameter>();
if (value.hasParameters()) {
for (ValueParameter valueParameter : value.getParameters()) {
valueParameter.setValue(freshValue);
newParams.add(valueParameterDAO.create(valueParameter).clone());
newParams.get(newParams.size() - 1).setValue(freshValueClone);
}
}
freshValueClone.setParameters(newParams.isEmpty() ? null : newParams);
return freshValueClone;
}
@Override
@Secured
public void removeAttachment(TestExecutionAttachment attachment) throws ServiceException {
TestExecution exec = testExecutionDAO.get(attachment.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.removeAttachment.testExecutionNotFound",
attachment.getTestExecution().getName());
}
TestExecutionAttachment freshAttachment = testExecutionAttachmentDAO.get(attachment.getId());
if (freshAttachment != null) {
testExecutionAttachmentDAO.remove(freshAttachment);
}
}
@Override
@Secured
public void removeValue(Value value) throws ServiceException {
TestExecution exec = testExecutionDAO.get(value.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.removeValue.testExecutionNotFound", value.getTestExecution().getName());
}
Value v = valueDAO.get(value.getId());
for (ValueParameter vp : v.getParameters()) {
valueParameterDAO.remove(vp);
}
valueDAO.remove(v);
}
@Override
@Secured
public TestExecutionParameter updateParameter(TestExecutionParameter tep)
throws ServiceException {
TestExecution exec = testExecutionDAO.get(tep.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.testExecutionNotFound", tep.getTestExecution().getName());
}
if (testExecutionParameterDAO.hasTestParam(exec.getId(), tep)) {
throw new ServiceException("serviceException.parameterExists", tep.getName());
}
return testExecutionParameterDAO.update(tep);
}
@Override
public SearchResultWrapper<TestExecution> searchTestExecutions(TestExecutionSearchTO search) {
// remove param criteria with empty param name
if (search.getParameters() != null) {
for (Iterator<ParamCriteria> allParams = search.getParameters().iterator();
allParams.hasNext(); ) {
ParamCriteria param = allParams.next();
if (param.isNameEmpty()) {
allParams.remove();
}
}
}
return testExecutionDAO.searchTestExecutions(search, userService.getLoggedUserGroupNames());
}
@Override
@Secured
public Value updateValue(Value value) throws ServiceException {
TestExecution exec = testExecutionDAO.get(value.getTestExecution().getId());
if (exec == null) {
throw new ServiceException(
"serviceException.updateValue.testExecutionNotFound", value.getTestExecution().getName());
}
Value oldValue = valueDAO.get(value.getId());
if (oldValue == null) {
throw new ServiceException("serviceException.valueNotFound");
}
Value freshValue = valueDAO.update(value);
Value freshValueClone = freshValue.clone();
freshValueClone.setMetric(freshValue.getMetric().clone());
freshValueClone.getMetric().setValues(null);
UpdateSet<ValueParameter> updateSet =
EntityUtils.updateSet(oldValue.getParameters(), value.getParameters());
if (!updateSet.removed.isEmpty()) {
throw new ServiceException("serviceException.staleCollection");
}
List<ValueParameter> newParams = new ArrayList<ValueParameter>();
for (ValueParameter vp : updateSet.toAdd) {
vp.setValue(freshValue);
newParams.add(valueParameterDAO.create(vp).clone());
newParams.get(newParams.size() - 1).setValue(freshValueClone);
}
for (ValueParameter vp : updateSet.toUpdate) {
newParams.add(valueParameterDAO.update(vp).clone());
newParams.get(newParams.size() - 1).setValue(freshValueClone);
}
for (ValueParameter vp : updateSet.toRemove) {
valueParameterDAO.remove(vp);
}
freshValueClone.setParameters(newParams.isEmpty() ? null : newParams);
return freshValueClone;
}
@Override
public TestExecution getFullTestExecution(Long id) {
return cloneAndFetch(testExecutionDAO.get(id), true, true, true, true, true);
}
@Override
public List<TestExecution> getExecutionsByTest(Long testId) {
return testExecutionDAO.getByTest(testId);
}
@Override
@Secured
public TestExecution createTestExecution(TestExecution testExecution) throws ServiceException {
// The test referred by test execution has to be an existing test
Test test = testDAO.get(testExecution.getTest().getId());
testExecution.setTest(test);
TestExecution storedTestExecution = testExecutionDAO.create(testExecution);
// execution params
if (testExecution.getParameters() != null && testExecution.getParameters().size() > 0) {
for (TestExecutionParameter param : testExecution.getParameters()) {
param.setTestExecution(storedTestExecution);
testExecutionParameterDAO.create(param);
}
}
// tags
if (testExecution.getTags() != null && testExecution.getTags().size() > 0) {
for (Tag teg : testExecution.getTags()) {
Tag tag = tagDAO.findByName(teg.getName());
if (tag == null) {
tag = tagDAO.create(teg);
}
Collection<TestExecution> tagTestExecutions = tag.getTestExecutions();
if (tagTestExecutions == null) {
tag.setTestExecutions(new ArrayList<>());
}
tag.getTestExecutions().add(storedTestExecution);
}
}
// values
if (testExecution.getValues() != null && !testExecution.getValues().isEmpty()) {
for (Value value : testExecution.getValues()) {
value.setTestExecution(storedTestExecution);
if (value.getMetricName() == null) {
throw new IllegalArgumentException("Metric name is mandatory");
}
Metric metric =
test.getMetrics()
.stream()
.filter(m -> m.getName().equals(value.getMetricName()))
.findFirst()
.get();
if (metric == null) {
throw new ServiceException(
"serviceException.metricNotInTest",
test.getName(),
test.getId().toString(),
value.getMetricName());
}
value.setMetric(metric);
valueDAO.create(value);
if (value.getParameters() != null && value.getParameters().size() > 0) {
for (ValueParameter vp : value.getParameters()) {
vp.setValue(value);
valueParameterDAO.create(vp);
}
}
}
}
TestExecution clone = cloneAndFetch(storedTestExecution, true, true, true, true, true);
log.debug("Created new test execution " + clone.getId());
alertingService.processAlerts(clone);
return clone;
}