/**
  * Instantiates a new Aggregated test case result.
  *
  * @param testCase the test case
  * @param status the status
  * @param errorCount the error count
  * @param prevalenceCount the prevalence count
  */
 public AggregatedTestCaseResultImpl(
     TestCase testCase, TestCaseResultStatus status, long errorCount, long prevalenceCount) {
   this(
       testCase.getTestURI(),
       testCase.getLogLevel(),
       testCase.getResultMessage(),
       status,
       errorCount,
       prevalenceCount);
 }
예제 #2
0
  /** {@inheritDoc} */
  @Override
  protected Collection<TestCaseResult> executeSingleTest(TestSource testSource, TestCase testCase)
      throws TestCaseExecutionException {

    Collection<TestCaseResult> testCaseResults = new ArrayList<>();
    PropertyValuePairSet.PropertyValuePairSetBuilder annotationSetBuilder =
        PropertyValuePairSet.builder();

    try (QueryExecution qe =
        testSource
            .getExecutionFactory()
            .createQueryExecution(queryGenerationFactory.getSparqlQuery(testCase))) {

      ResultSet results = qe.execSelect();

      ExtendedTestCaseResultImpl.Builder resultBuilder = null;
      String prevResource = "";

      while (results.hasNext()) {

        QuerySolution qs = results.next();

        String resource = qs.get("this").toString();
        if (qs.get("this").isLiteral()) {
          resource = StringUtils.getHashFromString(resource);
        }
        String message = testCase.getResultMessage();
        if (qs.contains("message")) {
          message = qs.get("message").toString();
        }
        RLOGLevel logLevel = testCase.getLogLevel();

        // If resource != before
        // we add the previous result in the list
        if (!prevResource.equals(resource)) {
          // The very first time we enter, result = null and we don't add any result
          if (resultBuilder != null) {
            testCaseResults.add(
                resultBuilder
                    .setResultAnnotations(annotationSetBuilder.build().getAnnotations())
                    .build());
          }

          resultBuilder =
              new ExtendedTestCaseResultImpl.Builder(
                  testCase.getTestURI(), logLevel, message, resource);

          annotationSetBuilder = PropertyValuePairSet.builder(); // reset

          // get static annotations for new test
          for (ResultAnnotation resultAnnotation : testCase.getResultAnnotations()) {
            // Get values
            if (resultAnnotation.getAnnotationValue().isPresent()) {
              annotationSetBuilder.annotation(
                  PropertyValuePair.create(
                      resultAnnotation.getAnnotationProperty(),
                      resultAnnotation.getAnnotationValue().get()));
            }
          }
        }

        // result must be initialized by now
        checkNotNull(resultBuilder);

        // get annotations from the SPARQL query
        for (ResultAnnotation resultAnnotation : testCase.getVariableAnnotations()) {
          // Get the variable name
          if (resultAnnotation.getAnnotationVarName().isPresent()) {
            String variable = resultAnnotation.getAnnotationVarName().get().trim();
            // If it exists, add it in the Set
            if (qs.contains(variable)) {
              annotationSetBuilder.annotation(
                  PropertyValuePair.create(
                      resultAnnotation.getAnnotationProperty(), qs.get(variable)));
            }
          }
        }
      }
      // Add last result (if query return any)
      if (resultBuilder != null) {
        testCaseResults.add(
            resultBuilder
                .setResultAnnotations(annotationSetBuilder.build().getAnnotations())
                .build());
      }
    } catch (QueryExceptionHTTP e) {
      checkQueryResultStatus(e);
    }

    return testCaseResults;
  }
예제 #3
0
  /**
   * main.
   *
   * @param args an array of {@link java.lang.String} objects.
   * @throws java.lang.Exception if any.
   */
  public static void main(String[] args) throws Exception {

    CommandLine commandLine = ValidateUtils.parseArguments(args);

    if (commandLine.hasOption("h")) {
      displayHelpAndExit();
    }

    String dataFolder = commandLine.getOptionValue("f", "../data/");

    if (!commandLine.hasOption('v')) { // explicitely do not use LOV
      RDFUnitUtils.fillSchemaServiceFromLOV();
    }
    // TODO hack until we fix this, configuration tries to laod schemas so they must be initialized
    // before
    RDFUnitUtils.fillSchemaServiceFromFile(dataFolder + "schemaDecl.csv");
    // RDFUnitUtils.fillSchemaServiceFromFile(configuration.getDataFolder() + "schemaDecl.csv");

    RDFUnitConfiguration configuration = null;
    try {
      configuration = ValidateUtils.getConfigurationFromArguments(commandLine);
    } catch (ParameterException e) {
      String message = e.getMessage();
      if (message != null) {
        displayHelpAndExit(message);
      } else {
        displayHelpAndExit();
      }
    }
    checkNotNull(configuration);

    if (!RDFUnitUtils.fileExists(configuration.getDataFolder())) {
      log.error("Path : " + configuration.getDataFolder() + " does not exists, use -f argument");
      System.exit(1);
    }

    RDFUnit rdfunit = new RDFUnit(configuration.getDataFolder());
    try {
      rdfunit.init();
    } catch (RDFReaderException e) {
      displayHelpAndExit("Cannot read patterns and/or pattern generators");
    }
    /*
    // Generates all tests from LOV
    for (Source s: SchemaService.getSourceListAll()) {
        s.setBaseCacheFolder("../data/tests/");
        File f = new File(s.getTestFile());
        if (!f.exists()) {
            List<TestCase> testsAuto = TestUtils.instantiateTestsFromAG(rdfunit.getAutoGenerators(), s);
            TestUtils.writeTestsToFile(testsAuto,  s.getTestFile());
        }
    }
    // */

    final TestSource dataset = configuration.getTestSource();
    /* </cliStuff> */

    TestGeneratorExecutor testGeneratorExecutor =
        new TestGeneratorExecutor(
            configuration.isAutoTestsEnabled(),
            configuration.isTestCacheEnabled(),
            configuration.isManualTestsEnabled());
    TestSuite testSuite =
        testGeneratorExecutor.generateTestSuite(
            configuration.getTestFolder(), dataset, rdfunit.getAutoGenerators());

    TestExecutor testExecutor =
        TestExecutorFactory.createTestExecutor(configuration.getTestCaseExecutionType());
    if (testExecutor == null) {
      displayHelpAndExit("Cannot initialize test executor. Exiting");
    }
    SimpleTestExecutorMonitor testExecutorMonitor = new SimpleTestExecutorMonitor();
    testExecutorMonitor.setExecutionType(configuration.getTestCaseExecutionType());
    checkNotNull(testExecutor);
    testExecutor.addTestExecutorMonitor(testExecutorMonitor);

    // warning, caches intermediate results
    testExecutor.execute(dataset, testSuite);

    // Write results to RDFWriter ()
    String filename =
        "../data/results/"
            + dataset.getPrefix()
            + "."
            + configuration.getTestCaseExecutionType().toString();

    ArrayList<RDFWriter> outputWriters = new ArrayList<>();
    for (SerializationFormat serializationFormat : configuration.getOutputFormats()) {
      outputWriters.add(
          RDFWriterFactory.createWriterFromFormat(
              filename, serializationFormat, configuration.getTestCaseExecutionType()));
    }

    RDFWriter resultWriter = new RDFMultipleWriter(outputWriters);
    try {
      resultWriter.write(testExecutorMonitor.getModel());
      log.info("Results stored in: " + filename + ".*");
    } catch (RDFWriterException e) {
      log.error("Cannot write tests to file: " + e.getMessage());
    }

    // Calculate coverage
    if (configuration.isCalculateCoverageEnabled()) {
      Model model = ModelFactory.createDefaultModel();
      PrefixNSService.setNSPrefixesInModel(model);
      for (TestCase ut : testSuite.getTestCases()) {
        model.add(ut.getUnitTestModel());
      }

      TestCoverageEvaluator tce = new TestCoverageEvaluator();
      tce.calculateCoverage(
          new QueryExecutionFactoryModel(model),
          dataset.getPrefix() + ".property.count",
          dataset.getPrefix() + ".class.count");
    }
  }
예제 #4
0
 /**
  * Constructor
  *
  * @param testCase the test case this result is related with
  */
 protected BaseTestCaseResultImpl(TestCase testCase) {
   this(testCase.getTestURI(), testCase.getLogLevel(), testCase.getResultMessage());
 }