javax.resource.cci.RecordFactory Java Examples

public MappedRecord mapFunctionMapValuesToMappedRecord(final String bapiName,
                                                       final RecordFactory recordFactory,
                                                       final Map<String, Object> functionMap) throws ResourceException {
    LOG.debug("mapFunctionMapValuesToMappedRecord() functionMap=" + functionMap);

    MappedRecord mappedInputRecord = recordFactory.createMappedRecord(bapiName);

    final Map<String, Object> importMap = UnsafeCastHelper.castToMap(functionMap.get(BapiConstants.IMPORT));
    mapToMappedRecord(recordFactory, mappedInputRecord, importMap);

    final Map<String, Object> changingMap = UnsafeCastHelper.castToMap(functionMap.get(BapiConstants.CHANGING));
    mapToMappedRecord(recordFactory, mappedInputRecord, changingMap);

    final Map<String, Object> tableMap = UnsafeCastHelper.castToMap(functionMap.get(TABLE));
    mapToMappedRecord(recordFactory, mappedInputRecord, tableMap);

    LOG.debug("mapFunctionMapValuesToMappedRecord() record=" + mappedInputRecord);

    return mappedInputRecord;
}
 

/**
 * Execute the specified interaction on an EIS with CCI.
 * All other interaction execution methods go through this.
 * @param spec the CCI InteractionSpec instance that defines
 * the interaction (connector-specific)
 * @param inputRecord the input record
 * @param outputRecord output record (can be {@code null})
 * @param outputExtractor object to convert the output record to a result object
 * @return the output data extracted with the RecordExtractor object
 * @throws DataAccessException if there is any problem
 */
protected <T> T doExecute(
		final InteractionSpec spec, final Record inputRecord, final Record outputRecord,
		final RecordExtractor<T> outputExtractor) throws DataAccessException {

	return execute(new InteractionCallback<T>() {
		@Override
		public T doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)
				throws ResourceException, SQLException, DataAccessException {
			Record outputRecordToUse = outputRecord;
			try {
				if (outputRecord != null || getOutputRecordCreator() != null) {
					// Use the CCI execute method with output record as parameter.
					if (outputRecord == null) {
						RecordFactory recordFactory = getRecordFactory(connectionFactory);
						outputRecordToUse = getOutputRecordCreator().createRecord(recordFactory);
					}
					interaction.execute(spec, inputRecord, outputRecordToUse);
				}
				else {
					outputRecordToUse = interaction.execute(spec, inputRecord);
				}
				return (outputExtractor != null ? outputExtractor.extractData(outputRecordToUse) : null);
			}
			finally {
				if (outputRecordToUse instanceof ResultSet) {
					closeResultSet((ResultSet) outputRecordToUse);
				}
			}
		}
	});
}
 

@Test
public void testCreateIndexedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	IndexedRecord indexedRecord = mock(IndexedRecord.class);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createIndexedRecord("name")).willReturn(indexedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createIndexedRecord("name");

	verify(recordFactory).createIndexedRecord("name");
}
 

@Test
public void testCreateIndexedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	IndexedRecord indexedRecord = mock(IndexedRecord.class);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createIndexedRecord("name")).willReturn(indexedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createIndexedRecord("name");

	verify(recordFactory).createIndexedRecord("name");
}
 

@Test
public void testCreateMappedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	MappedRecord mappedRecord = mock(MappedRecord.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createMappedRecord("name")).willReturn(mappedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createMappedRecord("name");

	verify(recordFactory).createMappedRecord("name");
}
 

@Test
public void testTemplateExecuteWithCreatorAndRecordFactoryNotSupported()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);

	Record inputRecord = mock(Record.class);
	final Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connectionFactory.getRecordFactory()).willThrow(new NotSupportedException("not supported"));
	given(connection.createInteraction()).willReturn(interaction);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(new RecordCreator() {
		@Override
		public Record createRecord(RecordFactory recordFactory) {
			assertTrue(recordFactory instanceof NotSupportedRecordFactory);
			return outputRecord;
		}
	});
	ct.execute(interactionSpec, inputRecord);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputTrueWithCreator2()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	final Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, inputRecord);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputExtractorTrueWithCreator()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
	given(extractor.extractData(outputRecord)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, inputRecord, extractor);

	verify(extractor).extractData(outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputGeneratorTrueWithCreator()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);


	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, generator);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputGeneratorFalse()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator);

	verify(interaction).execute(interactionSpec, inputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorTrueWithCreator()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	Object obj = new Object();

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
	given(extractor.extractData(outputRecord)).willReturn(obj);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	assertEquals(obj, ct.execute(interactionSpec, generator, extractor));

	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorFalse()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
	given(extractor.extractData(outputRecord)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator, extractor);

	verify(extractor).extractData(outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputOutputResultsSetFalse()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	Record record = mock(Record.class);
	ResultSet resultset = mock(ResultSet.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(record);
	given(interaction.execute(interactionSpec, record)).willReturn(resultset);
	given(extractor.extractData(resultset)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator, extractor);

	verify(extractor).extractData(resultset);
	verify(resultset).close();
	verify(interaction).close();
	verify(connection).close();
}
 

@Override
protected final Record createInputRecord(RecordFactory recordFactory, Object inObject) {
	try {
		return new CommAreaRecord(objectToBytes(inObject));
	}
	catch (IOException ex) {
		throw new DataRetrievalFailureException("I/O exception during bytes conversion", ex);
	}
}
 

/**
 * Execute the specified interaction on an EIS with CCI.
 * All other interaction execution methods go through this.
 * @param spec the CCI InteractionSpec instance that defines
 * the interaction (connector-specific)
 * @param inputRecord the input record
 * @param outputRecord output record (can be {@code null})
 * @param outputExtractor object to convert the output record to a result object
 * @return the output data extracted with the RecordExtractor object
 * @throws DataAccessException if there is any problem
 */
protected <T> T doExecute(
		final InteractionSpec spec, final Record inputRecord, final Record outputRecord,
		final RecordExtractor<T> outputExtractor) throws DataAccessException {

	return execute(new InteractionCallback<T>() {
		@Override
		public T doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)
				throws ResourceException, SQLException, DataAccessException {
			Record outputRecordToUse = outputRecord;
			try {
				if (outputRecord != null || getOutputRecordCreator() != null) {
					// Use the CCI execute method with output record as parameter.
					if (outputRecord == null) {
						RecordFactory recordFactory = getRecordFactory(connectionFactory);
						outputRecordToUse = getOutputRecordCreator().createRecord(recordFactory);
					}
					interaction.execute(spec, inputRecord, outputRecordToUse);
				}
				else {
					outputRecordToUse = interaction.execute(spec, inputRecord);
				}
				return (outputExtractor != null ? outputExtractor.extractData(outputRecordToUse) : null);
			}
			finally {
				if (outputRecordToUse instanceof ResultSet) {
					closeResultSet((ResultSet) outputRecordToUse);
				}
			}
		}
	});
}
 

@Override
protected final Record createInputRecord(RecordFactory recordFactory, Object inObject) {
	try {
		return new CommAreaRecord(objectToBytes(inObject));
	}
	catch (IOException ex) {
		throw new DataRetrievalFailureException("I/O exception during bytes conversion", ex);
	}
}
 

@Override
protected final Record createInputRecord(RecordFactory recordFactory, Object inObject) {
	try {
		return new CommAreaRecord(objectToBytes(inObject));
	}
	catch (IOException ex) {
		throw new DataRetrievalFailureException("I/O exception during bytes conversion", ex);
	}
}
 

@Test
public void testMappingRecordOperation() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordFactory recordFactory = mock(RecordFactory.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	QueryCallDetector callDetector = mock(QueryCallDetector.class);

	MappingRecordOperationImpl query = new MappingRecordOperationImpl(connectionFactory, interactionSpec);
	query.setCallDetector(callDetector);

	Object inObj = new Object();
	Object outObj = new Object();

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(callDetector.callCreateInputRecord(recordFactory, inObj)).willReturn(inputRecord);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
	given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);

	assertSame(outObj, query.execute(inObj));
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testMappingRecordOperationWithOutputRecordCreator() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordFactory recordFactory = mock(RecordFactory.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	RecordCreator outputCreator = mock(RecordCreator.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	QueryCallDetector callDetector = mock(QueryCallDetector.class);

	MappingRecordOperationImpl query = new MappingRecordOperationImpl(connectionFactory, interactionSpec);
	query.setOutputRecordCreator(outputCreator);
	query.setCallDetector(callDetector);

	Object inObj = new Object();
	Object outObj = new Object();

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(callDetector.callCreateInputRecord(recordFactory, inObj)).willReturn(inputRecord);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(outputCreator.createRecord(recordFactory)).willReturn(outputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
	given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);

	assertSame(outObj, query.execute(inObj));
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testCreateIndexedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	IndexedRecord indexedRecord = mock(IndexedRecord.class);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createIndexedRecord("name")).willReturn(indexedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createIndexedRecord("name");

	verify(recordFactory).createIndexedRecord("name");
}
 

@Test
public void testCreateMappedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	MappedRecord mappedRecord = mock(MappedRecord.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createMappedRecord("name")).willReturn(mappedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createMappedRecord("name");

	verify(recordFactory).createMappedRecord("name");
}
 

@Test
public void testTemplateExecuteWithCreatorAndRecordFactoryNotSupported()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);

	Record inputRecord = mock(Record.class);
	final Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connectionFactory.getRecordFactory()).willThrow(new NotSupportedException("not supported"));
	given(connection.createInteraction()).willReturn(interaction);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(new RecordCreator() {
		@Override
		public Record createRecord(RecordFactory recordFactory) {
			assertTrue(recordFactory instanceof NotSupportedRecordFactory);
			return outputRecord;
		}
	});
	ct.execute(interactionSpec, inputRecord);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputTrueWithCreator2()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	final Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, inputRecord);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputExtractorTrueWithCreator()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
	given(extractor.extractData(outputRecord)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, inputRecord, extractor);

	verify(extractor).extractData(outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputGeneratorTrueWithCreator()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);


	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	ct.execute(interactionSpec, generator);

	verify(interaction).execute(interactionSpec, inputRecord, outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@Test
public void testTemplateExecuteInputGeneratorFalse()
		throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator);

	verify(interaction).execute(interactionSpec, inputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorTrueWithCreator()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);
	RecordCreator creator = mock(RecordCreator.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	Object obj = new Object();

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(creator.createRecord(recordFactory)).willReturn(outputRecord);
	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
	given(extractor.extractData(outputRecord)).willReturn(obj);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.setOutputRecordCreator(creator);
	assertEquals(obj, ct.execute(interactionSpec, generator, extractor));

	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputGeneratorExtractorFalse()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);

	Record inputRecord = mock(Record.class);
	Record outputRecord = mock(Record.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(inputRecord);
	given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
	given(extractor.extractData(outputRecord)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator, extractor);

	verify(extractor).extractData(outputRecord);
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
@Test
public void testTemplateExecuteInputOutputResultsSetFalse()
		throws ResourceException, SQLException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	Connection connection = mock(Connection.class);
	Interaction interaction = mock(Interaction.class);
	Record record = mock(Record.class);
	ResultSet resultset = mock(ResultSet.class);
	RecordCreator generator = mock(RecordCreator.class);
	RecordExtractor<Object> extractor = mock(RecordExtractor.class);

	InteractionSpec interactionSpec = mock(InteractionSpec.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(connectionFactory.getConnection()).willReturn(connection);
	given(connection.createInteraction()).willReturn(interaction);
	given(generator.createRecord(recordFactory)).willReturn(record);
	given(interaction.execute(interactionSpec, record)).willReturn(resultset);
	given(extractor.extractData(resultset)).willReturn(new Object());

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.execute(interactionSpec, generator, extractor);

	verify(extractor).extractData(resultset);
	verify(resultset).close();
	verify(interaction).close();
	verify(connection).close();
}
 

@SuppressWarnings("unchecked")
private void mapToMappedRecord(final RecordFactory recordFactory, final Record record, final Map<String, Object> map)
        throws ResourceException {
    for (final String fieldName : map.keySet()) {
        final Object value = map.get(fieldName);

        if (Map.class.isAssignableFrom(value.getClass())) {
            final Map<String, Object> structureMap = UnsafeCastHelper.castToMap(value);
            final Record structure = recordFactory.createMappedRecord(fieldName);

            appendToRecord(record, fieldName, structure);

            mapToMappedRecord(recordFactory, structure, structureMap);
        } else if (Collection.class.isAssignableFrom(value.getClass())) {
            final Collection<Map<String, Object>> tableMap = UnsafeCastHelper.castToCollectionOfMaps(value);
            final IndexedRecord table = recordFactory.createIndexedRecord(fieldName);

            appendToRecord(record, fieldName, table);

            int i = 0;
            for (final Map<String, Object> row : tableMap) {
                MappedRecord rowRecord = recordFactory.createMappedRecord(fieldName + ":row:" + i);
                mapToMappedRecord(recordFactory, rowRecord, row);
                table.add(rowRecord);
                i++;
            }
        } else {
            appendToRecord(record, fieldName, value);
        }
    }
}