Examples with TestsResult com.hp.octane.integrations.dto.tests.TestsResult used on opensource projects

Example 1 with TestsResult

use of com.hp.octane.integrations.dto.tests.TestsResult in project octane-ci-java-sdk by MicroFocus.

the class OctaneSDKBasicFunctionalityTest method initSPEPSimulators.

private Map<String, OctaneSPEndpointSimulator> initSPEPSimulators(Set<String> spIDs, Map<String, List<CIEventsList>> eventsCollectors, Map<String, List<TestsResult>> testResultsCollectors, Map<String, List<String>> logsCollectors, Map<String, List<String>> coverageCollectors) {
    Map<String, OctaneSPEndpointSimulator> result = new LinkedHashMap<>();
    for (String spID : spIDs) {
        OctaneSPEndpointSimulator simulator = OctaneSPEndpointSimulator.addInstance(spID);
        // for octane roots
        simulator.setOctaneVersion("15.1.8");
        // events API
        simulator.installApiHandler(HttpMethod.PUT, "^.*events$", request -> {
            try {
                String rawEventsBody = CIPluginSDKUtils.inputStreamToUTF8String(new GZIPInputStream(request.getInputStream()));
                CIEventsList eventsList = dtoFactory.dtoFromJson(rawEventsBody, CIEventsList.class);
                eventsCollectors.computeIfAbsent(spID, sp -> new LinkedList<>()).add(eventsList);
                request.getResponse().setStatus(HttpStatus.SC_OK);
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // test results preflight API
        simulator.installApiHandler(HttpMethod.GET, "^.*tests-result-preflight$", request -> {
            try {
                request.getResponse().setStatus(HttpStatus.SC_OK);
                request.getResponse().getWriter().write("true");
                request.getResponse().getWriter().flush();
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // test results push API
        simulator.installApiHandler(HttpMethod.POST, "^.*test-results$", request -> {
            try {
                String rawTestResultBody = CIPluginSDKUtils.inputStreamToUTF8String(new GZIPInputStream(request.getInputStream()));
                TestsResult testsResult = dtoFactory.dtoFromXml(rawTestResultBody, TestsResult.class);
                // [YG] below validations are done to ensure NEW API (via query params) aligned with an OLD API (data within XML)
                // [YG] in the future we'll remove OLD API and this validation should be done differently
                request.mergeQueryParameters("", request.getQueryString(), false);
                Assert.assertEquals(request.getQueryParameters().getString("instance-id"), testsResult.getBuildContext().getServerId());
                Assert.assertEquals(request.getQueryParameters().getString("job-ci-id"), testsResult.getBuildContext().getJobId());
                Assert.assertEquals(request.getQueryParameters().getString("build-ci-id"), testsResult.getBuildContext().getBuildId());
                testResultsCollectors.computeIfAbsent(spID, sp -> new LinkedList<>()).add(testsResult);
                request.getResponse().setStatus(HttpStatus.SC_ACCEPTED);
                request.getResponse().getWriter().write("{\"status\": \"queued\"}");
                request.getResponse().getWriter().flush();
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // logs/coverage preflight API
        simulator.installApiHandler(HttpMethod.GET, "^.*workspaceId$", request -> {
            try {
                request.getResponse().setStatus(HttpStatus.SC_OK);
                request.getResponse().getWriter().write("[\"1001\"]");
                request.getResponse().getWriter().flush();
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // logs push API
        simulator.installApiHandler(HttpMethod.POST, "^.*logs$", request -> {
            try {
                String rawLogBody = CIPluginSDKUtils.inputStreamToUTF8String(new GZIPInputStream(request.getInputStream()));
                logsCollectors.computeIfAbsent(spID, sp -> new LinkedList<>()).add(rawLogBody);
                request.getResponse().setStatus(HttpStatus.SC_OK);
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // coverage preflight API
        // no need to configure, since it's the same API as for logs, see above
        // coverage push API
        simulator.installApiHandler(HttpMethod.PUT, "^.*coverage$", request -> {
            try {
                String rawCoverageBody = CIPluginSDKUtils.inputStreamToUTF8String(new GZIPInputStream(request.getInputStream()));
                coverageCollectors.computeIfAbsent(spID, sp -> new LinkedList<>()).add(rawCoverageBody);
                request.getResponse().setStatus(HttpStatus.SC_OK);
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        // get roots
        simulator.installApiHandler(HttpMethod.GET, "^.*pipeline-roots$", request -> {
            try {
                request.getResponse().setStatus(HttpStatus.SC_OK);
                request.getResponse().getWriter().write("[]");
                request.getResponse().getWriter().flush();
            } catch (IOException ioe) {
                throw new RuntimeException(ioe);
            }
        });
        result.put(spID, simulator);
    }
    return result;
}

Example 2 with TestsResult

use of com.hp.octane.integrations.dto.tests.TestsResult in project octane-ci-java-sdk by MicroFocus.

the class PluginServicesBasicFunctionalityTest method getTestsResult.

@Override
public InputStream getTestsResult(String jobId, String buildId) {
    List<TestRun> testRuns = new LinkedList<>();
    for (int i = 20; i > 0; i--) {
        testRuns.add(dtoFactory.newDTO(TestRun.class).setModuleName("module").setClassName("class").setPackageName("package").setTestName("test").setDuration(1000).setResult(TestRunResult.FAILED));
    }
    TestsResult testsResult = dtoFactory.newDTO(TestsResult.class).setBuildContext(dtoFactory.newDTO(BuildContext.class).setJobId("job-a").setBuildId("1")).setTestRuns(testRuns);
    return dtoFactory.dtoToXmlStream(testsResult);
}

Example 3 with TestsResult

use of com.hp.octane.integrations.dto.tests.TestsResult in project octane-ci-java-sdk by MicroFocus.

the class TestsServiceNegativeTests method testF1.

@Test(expected = IllegalArgumentException.class)
public void testF1() throws IOException {
    TestsService testsService = client.getTestsService();
    TestsResult tr = null;
    ((TestsServiceImpl) testsService).pushTestsResult(tr, null, null);
}

Example 4 with TestsResult

use of com.hp.octane.integrations.dto.tests.TestsResult in project octane-ci-java-sdk by MicroFocus.

the class OctaneSDKBasicFunctionalityTest method testE2EFunctional.

@Test(timeout = 60000)
public void testE2EFunctional() throws ExecutionException, InterruptedException {
    Map<String, OctaneSPEndpointSimulator> simulators = null;
    Map<String, List<CIEventsList>> eventsCollectors = new LinkedHashMap<>();
    Map<String, List<TestsResult>> testResultsCollectors = new LinkedHashMap<>();
    Map<String, List<String>> logsCollectors = new LinkedHashMap<>();
    Map<String, List<String>> coverageCollectors = new LinkedHashMap<>();
    OctaneClient clientA = null;
    try {
        String spIdA = UUID.randomUUID().toString();
        String spIdB = UUID.randomUUID().toString();
        String clientAInstanceId = UUID.randomUUID().toString();
        String clientBInstanceId = UUID.randomUUID().toString();
        // init 2 shared space endpoints simulators
        simulators = initSPEPSimulators(Stream.of(spIdA, spIdB).collect(Collectors.toSet()), eventsCollectors, testResultsCollectors, logsCollectors, coverageCollectors);
        // 
        // I
        // add one client and verify it works okay
        // 
        System.out.println("Scenario 1 - add one client and verify it works okay");
        clientA = OctaneSDK.addClient(new OctaneConfigurationBasicFunctionalityTest(clientAInstanceId, OctaneSPEndpointSimulator.getSimulatorUrl(), spIdA, "client_SP_A", "secret_SP_A"), PluginServicesBasicFunctionalityTest.class);
        clientA.getConfigurationService().addToOctaneRootsCache("job-a");
        clientA.getConfigurationService().getOctaneConnectivityStatus();
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        // validate events
        GeneralTestUtils.waitAtMostFor(10000, () -> {
            if (eventsCollectors.containsKey(spIdA) && eventsCollectors.get(spIdA).stream().mapToInt(cil -> cil.getEvents().size()).sum() == 3) {
                eventsCollectors.get(spIdA).forEach(cil -> {
                    Assert.assertNotNull(cil);
                    Assert.assertNotNull(cil.getServer());
                    Assert.assertEquals(clientAInstanceId, cil.getServer().getInstanceId());
                    Assert.assertEquals("custom", cil.getServer().getType());
                    Assert.assertEquals("1.1.1", cil.getServer().getVersion());
                    Assert.assertEquals("http://localhost:9999", cil.getServer().getUrl());
                });
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate tests
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (testResultsCollectors.containsKey(spIdA) && testResultsCollectors.get(spIdA).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate logs
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (logsCollectors.containsKey(spIdA) && logsCollectors.get(spIdA).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate coverage
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (coverageCollectors.containsKey(spIdA) && coverageCollectors.get(spIdA).size() == 2) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // 
        // II
        // add one more client and verify they are both works okay
        // 
        System.out.println("Scenario 2 - add one more client and verify they are both works okay");
        OctaneClient clientB = OctaneSDK.addClient(new OctaneConfigurationBasicFunctionalityTest(clientBInstanceId, OctaneSPEndpointSimulator.getSimulatorUrl(), spIdB, "client_SP_B", "secret_SP_B"), PluginServicesBasicFunctionalityTest.class);
        clientB.getConfigurationService().addToOctaneRootsCache("job-a");
        clientB.getConfigurationService().getOctaneConnectivityStatus();
        eventsCollectors.get(spIdA).clear();
        testResultsCollectors.get(spIdA).clear();
        logsCollectors.get(spIdA).clear();
        coverageCollectors.get(spIdA).clear();
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        // validate events
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (eventsCollectors.containsKey(spIdA) && eventsCollectors.get(spIdA).stream().mapToInt(cil -> cil.getEvents().size()).sum() == 3 && eventsCollectors.containsKey(spIdB) && eventsCollectors.get(spIdA).stream().mapToInt(cil -> cil.getEvents().size()).sum() == 3) {
                // client A
                eventsCollectors.get(spIdA).forEach(cil -> {
                    Assert.assertNotNull(cil);
                    Assert.assertNotNull(cil.getServer());
                    Assert.assertEquals(clientAInstanceId, cil.getServer().getInstanceId());
                    Assert.assertEquals("custom", cil.getServer().getType());
                    Assert.assertEquals("1.1.1", cil.getServer().getVersion());
                    Assert.assertEquals("http://localhost:9999", cil.getServer().getUrl());
                });
                // client B
                eventsCollectors.get(spIdB).forEach(cil -> {
                    Assert.assertNotNull(cil);
                    Assert.assertNotNull(cil.getServer());
                    Assert.assertEquals(clientBInstanceId, cil.getServer().getInstanceId());
                    Assert.assertEquals("custom", cil.getServer().getType());
                    Assert.assertEquals("1.1.1", cil.getServer().getVersion());
                    Assert.assertEquals("http://localhost:9999", cil.getServer().getUrl());
                });
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate tests
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (testResultsCollectors.containsKey(spIdA) && testResultsCollectors.get(spIdA).size() == 1 && testResultsCollectors.containsKey(spIdB) && testResultsCollectors.get(spIdB).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate logs
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (logsCollectors.containsKey(spIdA) && logsCollectors.get(spIdA).size() == 1 && logsCollectors.containsKey(spIdB) && logsCollectors.get(spIdB).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate coverages
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (coverageCollectors.containsKey(spIdA) && coverageCollectors.get(spIdA).size() == 2 && coverageCollectors.containsKey(spIdB) && coverageCollectors.get(spIdB).size() == 2) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // 
        // III
        // remove one client and verify it is shut indeed and the second continue to work okay
        // 
        System.out.println("Scenario 3 - remove one client and verify it is shut indeed and the second continue to work okay");
        OctaneSDK.removeClient(clientA);
        eventsCollectors.get(spIdA).clear();
        eventsCollectors.get(spIdB).clear();
        testResultsCollectors.get(spIdA).clear();
        testResultsCollectors.get(spIdB).clear();
        logsCollectors.get(spIdA).clear();
        logsCollectors.get(spIdB).clear();
        coverageCollectors.get(spIdA).clear();
        coverageCollectors.get(spIdB).clear();
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        // validate events
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (eventsCollectors.containsKey(spIdB) && eventsCollectors.get(spIdB).stream().mapToInt(cil -> cil.getEvents().size()).sum() == 3) {
                Assert.assertTrue(eventsCollectors.get(spIdA).isEmpty());
                eventsCollectors.get(spIdB).forEach(cil -> {
                    Assert.assertNotNull(cil);
                    Assert.assertNotNull(cil.getServer());
                    Assert.assertEquals(clientBInstanceId, cil.getServer().getInstanceId());
                    Assert.assertEquals("custom", cil.getServer().getType());
                    Assert.assertEquals("1.1.1", cil.getServer().getVersion());
                    Assert.assertEquals("http://localhost:9999", cil.getServer().getUrl());
                });
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate tests
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (testResultsCollectors.containsKey(spIdB) && testResultsCollectors.get(spIdB).size() == 1) {
                Assert.assertTrue(testResultsCollectors.get(spIdA).isEmpty());
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate logs
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (logsCollectors.containsKey(spIdB) && logsCollectors.get(spIdB).size() == 1) {
                Assert.assertTrue(logsCollectors.get(spIdA).isEmpty());
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate coverages
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (coverageCollectors.containsKey(spIdB) && coverageCollectors.get(spIdB).size() == 2) {
                Assert.assertTrue(coverageCollectors.get(spIdA).isEmpty());
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // 
        // IV
        // remove second client and ensure no interactions anymore
        // 
        System.out.println("Scenario 4 - remove second client and ensure no interactions anymore");
        OctaneSDK.removeClient(clientB);
        eventsCollectors.get(spIdB).clear();
        testResultsCollectors.get(spIdB).clear();
        logsCollectors.get(spIdB).clear();
        coverageCollectors.get(spIdB).clear();
        // events, tests, logs
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        CIPluginSDKUtils.doWait(4000);
        Assert.assertTrue(eventsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(eventsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdB).isEmpty());
        // 
        // V
        // add clientA in with deactivated Mode
        // 
        System.out.println("Scenario 5 - add clientA in with deactivated Mode");
        clientA = OctaneSDK.addClient(new OctaneConfigurationBasicFunctionalityTest(clientAInstanceId, OctaneSPEndpointSimulator.getSimulatorUrl(), spIdA, "client_SP_A", "secret_SP_A"), PluginServicesBasicFunctionalityTest.class);
        clientA.getConfigurationService().getConfiguration().setSuspended(true);
        clientA.getConfigurationService().getOctaneConnectivityStatus();
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        CIPluginSDKUtils.doWait(4000);
        Assert.assertTrue(eventsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(eventsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdB).isEmpty());
        OctaneSDK.removeClient(clientA);
        // 
        // 6
        // add client with parameter OCTANE_ROOTS_CACHE_ALLOWED=true with no pipeline root
        // 
        System.out.println("Scenario 6 - add client with parameter OCTANE_ROOTS_CACHE_ALLOWED=true with no pipeline root");
        OctaneConfiguration tempConf = new OctaneConfigurationBasicFunctionalityTest(clientAInstanceId, OctaneSPEndpointSimulator.getSimulatorUrl(), spIdA, "client_SP_A", "secret_SP_A");
        ConfigurationParameterFactory.addParameter(tempConf, "OCTANE_ROOTS_CACHE_ALLOWED", "true");
        clientA = OctaneSDK.addClient(tempConf, PluginServicesBasicFunctionalityTest.class);
        clientA.getConfigurationService().getOctaneConnectivityStatus();
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        CIPluginSDKUtils.doWait(4000);
        Assert.assertTrue(eventsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(eventsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(testResultsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(logsCollectors.get(spIdB).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdA).isEmpty());
        Assert.assertTrue(coverageCollectors.get(spIdB).isEmpty());
        // 
        // 7
        // add client with parameter OCTANE_ROOTS_CACHE_ALLOWED=true with one root
        // 
        System.out.println("Scenario 7 - add client with parameter OCTANE_ROOTS_CACHE_ALLOWED=true with one root");
        clientA.getConfigurationService().addToOctaneRootsCache("job-a");
        simulateEventsCycleAllClients();
        simulatePushTestResultsCycleAllClients();
        simulatePushLogsCycleAllClients();
        simulatePushCoverageAllClients();
        CIPluginSDKUtils.doWait(4000);
        // validate events
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (eventsCollectors.containsKey(spIdA) && eventsCollectors.get(spIdA).stream().mapToInt(cil -> cil.getEvents().size()).sum() == 3) {
                eventsCollectors.get(spIdA).forEach(cil -> {
                    Assert.assertNotNull(cil);
                    Assert.assertNotNull(cil.getServer());
                    Assert.assertEquals(clientAInstanceId, cil.getServer().getInstanceId());
                    Assert.assertEquals("custom", cil.getServer().getType());
                    Assert.assertEquals("1.1.1", cil.getServer().getVersion());
                    Assert.assertEquals("http://localhost:9999", cil.getServer().getUrl());
                });
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate tests
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (testResultsCollectors.containsKey(spIdA) && testResultsCollectors.get(spIdA).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate logs
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (logsCollectors.containsKey(spIdA) && logsCollectors.get(spIdA).size() == 1) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
        // validate coverage
        GeneralTestUtils.waitAtMostFor(5000, () -> {
            if (coverageCollectors.containsKey(spIdA) && coverageCollectors.get(spIdA).size() == 2) {
                // TODO: add deeper verification
                return true;
            } else {
                return null;
            }
        });
    } finally {
        // remove clients
        OctaneSDK.getClients().forEach(OctaneSDK::removeClient);
        // remove simulators
        if (simulators != null)
            removeSPEPSimulators(simulators.values());
    }
}