Examples with Trans org.pentaho.di.trans.Trans used on opensource projects

Example 91 with Trans

use of org.pentaho.di.trans.Trans in project pentaho-kettle by pentaho.

the class GPBulkLoader method init.

public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
    meta = (GPBulkLoaderMeta) smi;
    data = (GPBulkLoaderData) sdi;
    Trans trans = getTrans();
    preview = trans.isPreview();
    if (super.init(smi, sdi)) {
        return true;
    }
    return false;
}

Example 92 with Trans

use of org.pentaho.di.trans.Trans in project pentaho-kettle by pentaho.

the class RunTransServletTest method testRunTransServletCheckParameter.

@Test
public void testRunTransServletCheckParameter() throws Exception {
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
    HttpServletResponse response = Mockito.mock(HttpServletResponse.class);
    Mockito.when(request.getParameter("trans")).thenReturn("home/test.rtr");
    StringWriter out = new StringWriter();
    PrintWriter printWriter = new PrintWriter(out);
    Mockito.when(request.getContextPath()).thenReturn(RunTransServlet.CONTEXT_PATH);
    Mockito.when(response.getWriter()).thenReturn(printWriter);
    TransformationMap mockTransformationMap = Mockito.mock(TransformationMap.class);
    SlaveServerConfig slaveServerConfig = Mockito.mock(SlaveServerConfig.class);
    Mockito.when(mockTransformationMap.getSlaveServerConfig()).thenReturn(slaveServerConfig);
    Repository repository = Mockito.mock(Repository.class);
    Mockito.when(slaveServerConfig.getRepository()).thenReturn(repository);
    RepositoryDirectoryInterface repositoryDirectoryInterface = Mockito.mock(RepositoryDirectoryInterface.class);
    Mockito.when(repository.loadRepositoryDirectoryTree()).thenReturn(repositoryDirectoryInterface);
    Mockito.when(repositoryDirectoryInterface.findDirectory(Mockito.anyString())).thenReturn(repositoryDirectoryInterface);
    TransMeta transMeta = Mockito.mock(TransMeta.class);
    Mockito.when(repository.loadTransformation(Mockito.any(), Mockito.any())).thenReturn(transMeta);
    String testParameter = "testParameter";
    Mockito.when(transMeta.listVariables()).thenReturn(new String[] { testParameter });
    Mockito.when(transMeta.getVariable(Mockito.anyString())).thenReturn("default value");
    Mockito.when(transMeta.listParameters()).thenReturn(new String[] { testParameter });
    Mockito.when(request.getParameterNames()).thenReturn(new StringTokenizer(testParameter));
    String testValue = "testValue";
    Mockito.when(request.getParameterValues(testParameter)).thenReturn(new String[] { testValue });
    RunTransServlet runTransServlet = Mockito.mock(RunTransServlet.class);
    Mockito.doCallRealMethod().when(runTransServlet).doGet(Mockito.anyObject(), Mockito.anyObject());
    Trans trans = new Trans(transMeta, new SimpleLoggingObject(RunTransServlet.CONTEXT_PATH, LoggingObjectType.CARTE, null));
    Mockito.when(runTransServlet.createTrans(Mockito.anyObject(), Mockito.anyObject())).thenReturn(trans);
    Mockito.when(transMeta.getParameterValue(Mockito.eq(testParameter))).thenReturn(testValue);
    runTransServlet.log = new LogChannel("RunTransServlet");
    runTransServlet.transformationMap = mockTransformationMap;
    runTransServlet.doGet(request, response);
    Assert.assertEquals(testValue, trans.getParameterValue(testParameter));
}

Example 93 with Trans

use of org.pentaho.di.trans.Trans in project pentaho-kettle by pentaho.

the class StopTransServletTest method testWillStopInputStepsOnly.

@Test
@PrepareForTest({ Encode.class })
public void testWillStopInputStepsOnly() throws ServletException, IOException {
    KettleLogStore.init();
    HttpServletRequest mockHttpServletRequest = mock(HttpServletRequest.class);
    HttpServletResponse mockHttpServletResponse = mock(HttpServletResponse.class);
    Trans mockTrans = mock(Trans.class);
    TransMeta mockTransMeta = mock(TransMeta.class);
    LogChannelInterface mockChannelInterface = mock(LogChannelInterface.class);
    StringWriter out = new StringWriter();
    PrintWriter printWriter = new PrintWriter(out);
    when(mockHttpServletRequest.getContextPath()).thenReturn(StopTransServlet.CONTEXT_PATH);
    when(mockHttpServletRequest.getParameter("inputOnly")).thenReturn("Y");
    when(mockHttpServletRequest.getParameter("name")).thenReturn("test");
    when(mockHttpServletRequest.getParameter("id")).thenReturn("123");
    when(mockHttpServletResponse.getWriter()).thenReturn(printWriter);
    when(mockTransformationMap.getTransformation(any(CarteObjectEntry.class))).thenReturn(mockTrans);
    when(mockTrans.getLogChannel()).thenReturn(mockChannelInterface);
    when(mockTrans.getLogChannelId()).thenReturn("test");
    when(mockTrans.getTransMeta()).thenReturn(mockTransMeta);
    stopTransServlet.doGet(mockHttpServletRequest, mockHttpServletResponse);
    Mockito.verify(mockTrans).safeStop();
}

Example 94 with Trans

use of org.pentaho.di.trans.Trans in project pentaho-kettle by pentaho.

the class BlackBoxIT method runTrans.

public Result runTrans(String fileName, LogChannelInterface log) throws KettleException {
    // Bootstrap the Kettle API...
    // 
    KettleEnvironment.init();
    TransMeta transMeta = new TransMeta(fileName);
    Trans trans = new Trans(transMeta);
    Result result;
    try {
        trans.setLogLevel(LogLevel.ERROR);
        result = trans.getResult();
    } catch (Exception e) {
        result = trans.getResult();
        String message = "Processing has stopped because of an error: " + getPath(fileName);
        addFailure(message);
        log.logError(message, e);
        fail(message);
        return result;
    }
    try {
        trans.initializeVariablesFrom(null);
        trans.getTransMeta().setInternalKettleVariables(trans);
        trans.setSafeModeEnabled(true);
        // see if the transformation checks ok
        List<CheckResultInterface> remarks = new ArrayList<CheckResultInterface>();
        trans.getTransMeta().checkSteps(remarks, false, null, new Variables(), null, null);
        for (CheckResultInterface remark : remarks) {
            if (remark.getType() == CheckResultInterface.TYPE_RESULT_ERROR) {
                // add this to the log
                addFailure("Check error: " + getPath(fileName) + ", " + remark.getErrorCode());
                log.logError("BlackBoxTest", "Check error: " + getPath(fileName) + ", " + remark.getErrorCode());
            }
        }
        // allocate & run the required sub-threads
        try {
            trans.execute(null);
        } catch (Exception e) {
            addFailure("Unable to prepare and initialize this transformation: " + getPath(fileName));
            log.logError("BlackBoxTest", "Unable to prepare and initialize this transformation: " + getPath(fileName));
            fail("Unable to prepare and initialize this transformation: " + getPath(fileName));
            return null;
        }
        trans.waitUntilFinished();
        result = trans.getResult();
        // The result flag is not set to true by a transformation - set it to true if got no errors
        // FIXME: Find out if there is a better way to check if a transformation has thrown an error
        result.setResult(result.getNrErrors() == 0);
        return result;
    } catch (Exception e) {
        addFailure("Unexpected error occurred: " + getPath(fileName));
        log.logError("BlackBoxTest", "Unexpected error occurred: " + getPath(fileName), e);
        result.setResult(false);
        result.setNrErrors(1);
        fail("Unexpected error occurred: " + getPath(fileName));
        return result;
    }
}

Example 95 with Trans

use of org.pentaho.di.trans.Trans in project pentaho-kettle by pentaho.

the class MetricsIT method testDatabaseGetRow.

@Test
public void testDatabaseGetRow() throws Exception {
    MetricsRegistry metricsRegistry = MetricsRegistry.getInstance();
    TransMeta insertTransMeta = new TransMeta("src/it/resources/metrics/insert-data.ktr");
    Trans insertTrans = new Trans(insertTransMeta);
    insertTrans.setGatheringMetrics(true);
    insertTrans.execute(null);
    insertTrans.waitUntilFinished();
    LogChannelInterface log = insertTrans.getLogChannel();
    Queue<MetricsSnapshotInterface> snapshotList = metricsRegistry.getSnapshotList(log.getLogChannelId());
    assertTrue(snapshotList.size() >= 4);
    TransMeta readTransMeta = new TransMeta("src/it/resources/metrics/read-data.ktr");
    Trans readTrans = new Trans(readTransMeta);
    readTrans.setGatheringMetrics(true);
    readTrans.execute(null);
    readTrans.waitUntilFinished();
    log = readTrans.getLogChannel();
    snapshotList = metricsRegistry.getSnapshotList(log.getLogChannelId());
    assertTrue(snapshotList.size() >= 4);
    Long rowCount = MetricsUtil.getResult(Metrics.METRIC_DATABASE_GET_ROW_COUNT);
    assertNotNull(rowCount);
    assertEquals(Long.valueOf(1001), rowCount);
    Long sumTime = MetricsUtil.getResult(Metrics.METRIC_DATABASE_GET_ROW_SUM_TIME);
    assertNotNull(sumTime);
    assertTrue(sumTime > 0);
    Long minTime = MetricsUtil.getResult(Metrics.METRIC_DATABASE_GET_ROW_MIN_TIME);
    assertNotNull(minTime);
    assertTrue(minTime < sumTime);
    Long maxTime = MetricsUtil.getResult(Metrics.METRIC_DATABASE_GET_ROW_MAX_TIME);
    assertNotNull(maxTime);
    assertTrue(maxTime >= minTime);
}