Пример #1
0
  @Override
  // @Secured TODO: we need to handle this property, since getTestByRelation will not work as metric
  // is associated with more tests
  public void removeMetric(Metric metric, Test test) throws ServiceException {
    Metric freshMetric = metricDAO.get(metric.getId());
    Test freshTest = testDAO.get(test.getId());

    // List<Test> newTests = freshMetric.getTests().stream().filter(o ->
    // !o.equals(freshTest)).collect(Collectors.toList());
    // freshMetric.setTests(newTests);

    // List<Metric> newMetrics = freshTest.getMetrics().stream().filter(o ->
    // !o.equals(freshMetric)).collect(Collectors.toList());
    // freshTest.setMetrics(newMetrics);

    freshMetric.getTests().remove(freshTest);
    freshTest.getMetrics().remove(freshMetric);

    metricDAO.update(freshMetric);
    testDAO.update(freshTest);

    if (freshMetric.getTests() == null || freshMetric.getTests().isEmpty()) {
      metricDAO.remove(freshMetric);
    }
  }
Пример #2
0
  @Override
  public void addSubscriber(User user, Test test) {
    Test freshTest = testDAO.get(test.getId());
    User freshUser = userDAO.get(user.getId());

    Collection<User> testSubscribers = freshTest.getSubscribers();
    if (testSubscribers.contains(freshUser)) {
      return;
    }

    testSubscribers.add(freshUser);
    testDAO.update(freshTest);
  }
Пример #3
0
  @Override
  @Secured
  public void removeTest(Test test) throws ServiceException {
    Test freshTest = testDAO.get(test.getId());
    try {
      for (TestExecution testExecution : freshTest.getTestExecutions()) {
        removeTestExecution(testExecution);
      }
    } catch (ServiceException ex) {
      throw new ServiceException("serviceException.removeTest.cannotRemoveAllTestExecutions", ex);
    }

    testDAO.remove(freshTest);
  }
Пример #4
0
  @Override
  public void removeSubscriber(User user, Test test) {
    Test freshTest = testDAO.get(test.getId());

    Collection<User> testSubscribers = new ArrayList<>(freshTest.getSubscribers());
    for (User testSubscriber : freshTest.getSubscribers()) {
      if (testSubscriber.getId().equals(user.getId())) {
        testSubscribers.remove(testSubscriber);
      }
    }

    test.setSubscribers(testSubscribers);
    testDAO.update(test);
  }
Пример #5
0
  @Override
  public SearchResultWrapper<Test> getAvailableTests() {
    TestSearchTO search = new TestSearchTO();
    search.setGroupFilter(GroupFilter.MY_GROUPS);
    List<String> groups = userService.getLoggedUserGroupNames();

    return testDAO.searchTests(search, groups);
  }
Пример #6
0
 @Override
 public List<Test> getAllFullTests() {
   List<Test> r = testDAO.getAll();
   List<Test> rcopy = new ArrayList<Test>(r.size());
   for (Test t : r) {
     rcopy.add(getFullTest(t.getId()));
   }
   return rcopy;
 }
Пример #7
0
  @Override
  public List<Metric> getAllMetrics(Long testId) {
    Test freshTest = testDAO.get(testId);
    if (freshTest.getMetrics() == null) {
      return new ArrayList<>();
    }

    List<Metric> metrics = freshTest.getMetrics().stream().collect(Collectors.toList());
    return metrics;
  }
Пример #8
0
 @Override
 public List<String> getTestsByPrefix(String prefix) {
   List<Test> tests = testDAO.findByUIDPrefix(prefix);
   List<String> testuids = new ArrayList<String>();
   for (Test test : tests) {
     if (userService.isLoggedUserInGroup(test.getGroupId())) {
       testuids.add(test.getUid());
     }
   }
   return testuids;
 }
Пример #9
0
 @Override
 public Test createTest(Test test) throws ServiceException {
   if (!userService.isLoggedUserInGroup(test.getGroupId())) {
     throw new org.perfrepo.web.security.SecurityException(
         "securityException.userNotInGroup.createTest",
         userService.getLoggedUser().getUsername(),
         test.getGroupId());
   }
   if (testDAO.findByUid(test.getUid()) != null) {
     throw new ServiceException("serviceException.testUidExists", test.getUid());
   }
   Test createdTest = testDAO.create(test);
   // store metrics
   if (test.getMetrics() != null) {
     for (Metric metric : test.getMetrics()) {
       addMetric(test, metric);
     }
   }
   return createdTest;
 }
Пример #10
0
  @Override
  public boolean isUserSubscribed(User user, Test test) {
    Test freshTest = testDAO.get(test.getId());
    Collection<User> testSubscribers = freshTest.getSubscribers();
    for (User testSubscriber : testSubscribers) {
      if (testSubscriber.getId().equals(user.getId())) {
        return true;
      }
    }

    return false;
  }
Пример #11
0
  @Override
  public Test getFullTest(Long id) {
    Test test = testDAO.get(id);
    if (test == null) {
      return null;
    }
    test = test.clone();
    // TODO: return by named query, with optimized fetching
    Collection<Metric> metrics = test.getMetrics();
    if (metrics != null) {
      List<Metric> clonedMetrics = new ArrayList<Metric>();
      for (Metric metric : metrics) {
        clonedMetrics.add(metric);
      }
      test.setMetrics(clonedMetrics);
    }

    Collection<User> subscribers = test.getSubscribers();
    if (subscribers != null) {
      List<User> subscribersClone = new ArrayList<>();
      for (User subscriber : subscribers) {
        subscribersClone.add(subscriber.clone());
      }
      test.setSubscribers(subscribersClone);
    }

    Collection<Alert> alerts = test.getAlerts();
    if (alerts != null) {
      List<Alert> alertsClone = new ArrayList<>();
      for (Alert alert : alerts) {
        List<Tag> tagsClone = new ArrayList<>();
        for (Tag tag : alert.getTags()) {
          tagsClone.add(tag.clone());
        }
        Alert alertClone = alert.clone();
        alertClone.setTags(tagsClone);
        alertsClone.add(alertClone);
      }
      test.setAlerts(alertsClone);
    }

    return test;
  }
Пример #12
0
 @Override
 public SearchResultWrapper<Test> searchTest(TestSearchTO search) {
   return testDAO.searchTests(search, userService.getLoggedUserGroupNames());
 }
Пример #13
0
 @Secured
 @Override
 public Test updateTest(Test test) {
   return testDAO.update(test);
 }
Пример #14
0
  @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;
  }
Пример #15
0
 @Override
 public Test getTest(Long id) {
   return testDAO.get(id);
 }
Пример #16
0
 @Override
 public List<Metric> getAvailableMetrics(Test test) {
   Test t = testDAO.get(test.getId());
   return EntityUtils.removeAllById(metricDAO.getMetricByGroup(t.getGroupId()), t.getMetrics());
 }
Пример #17
0
  @Override
  @Secured
  public Metric addMetric(Test test, Metric metric) throws ServiceException {
    Test freshTest = testDAO.get(test.getId());
    if (freshTest.getMetrics() == null) {
      freshTest.setMetrics(new ArrayList<>());
    }

    if (metric.getId() != null) {
      // associating an existing metric with the test
      Metric freshMetric = metricDAO.get(metric.getId());
      if (freshMetric == null) {
        throw new ServiceException("serviceException.metricNotFound", metric.getName().toString());
      }

      if (freshMetric.getTests() == null) {
        freshMetric.setTests(new ArrayList<>());
      }

      for (Test testForMetric : freshMetric.getTests()) {
        if (!testForMetric.getGroupId().equals(freshTest.getGroupId())) {
          throw new ServiceException("serviceException.metricSharingOnlyInGroup");
        }
        if (testForMetric.getId().equals(freshTest.getId())) {
          throw new ServiceException(
              "serviceException.metricAlreadyExists", freshTest.getUid(), freshMetric.getName());
        }
      }

      freshMetric.getTests().add(freshTest);
      freshTest.getMetrics().add(freshMetric);

      freshMetric = metricDAO.update(freshMetric);
      testDAO.update(freshTest);

      return freshMetric;
    } else {
      // creating a new metric object
      if (metric.getName() == null) {
        throw new IllegalArgumentException("Metric name is mandatory");
      }
      // metric name needs to be unique in the metric space of a certain groupId
      // does it exist in a test with same group id (including the target test) ?
      List<Metric> existingMetricsForGroup =
          metricDAO.getMetricByNameAndGroup(metric.getName(), freshTest.getGroupId());
      for (Metric existingMetric : existingMetricsForGroup) {
        if (existingMetric.getName().equals(metric.getName())) {
          Metric freshMetric = metricDAO.get(existingMetric.getId());

          if (freshMetric.getTests().stream().anyMatch(t -> t.getId().equals(freshTest.getId()))) {
            throw new ServiceException(
                "serviceException.metricAlreadyExists", freshTest.getUid(), freshMetric.getName());
          }
        }
      }

      metric.setTests(Arrays.asList(freshTest));
      Metric freshMetric = metricDAO.create(metric);

      freshTest.getMetrics().add(freshMetric);
      testDAO.update(freshTest);

      return freshMetric;
    }
  }
Пример #18
0
 @Override
 public List<Metric> getTestMetrics(Test test) {
   Test t = testDAO.get(test.getId());
   return t.getSortedMetrics();
 }
Пример #19
0
 @Override
 public List<Test> getAllTests() {
   return testDAO.getAll();
 }
Пример #20
0
 @Override
 public Test getTestByUID(String uid) {
   return testDAO.findByUid(uid);
 }