diff --git a/pkg/codec/encodings/type_codec_test.go b/pkg/codec/encodings/type_codec_test.go
index f4a689d072..1aa49506d8 100644
--- a/pkg/codec/encodings/type_codec_test.go
+++ b/pkg/codec/encodings/type_codec_test.go
@@ -33,7 +33,7 @@ func TestCodecFromTypeCodecs(t *testing.T) {
 	RunCodecInterfaceTests(t, lbiit)
 
 	t.Run("Lenient encoding allows extra bits", func(t *testing.T) {
-		ts := CreateTestStruct(0, lbiit)
+		ts := CreateTestStruct[*testing.T](0, lbiit)
 		c := lbiit.GetCodec(t)
 		encoded, err := c.Encode(tests.Context(t), ts, TestItemType)
 		require.NoError(t, err)
@@ -249,7 +249,7 @@ func (b *bigEndianInterfaceTester) GetCodec(t *testing.T) types.Codec {
 	arr2, err := encodings.NewArray(2, testStruct)
 	require.NoError(t, err)
 
-	ts := CreateTestStruct(0, b)
+	ts := CreateTestStruct[*testing.T](0, b)
 
 	tc := &encodings.CodecFromTypeCodec{
 		TestItemType:            testStruct,
diff --git a/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go b/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
index 0646a59940..8abadcf95b 100644
--- a/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
+++ b/pkg/loop/internal/relayer/pluginprovider/contractreader/contract_reader_test.go
@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -21,6 +22,7 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/loop/internal/pb"
 	"github.com/smartcontractkit/chainlink-common/pkg/loop/internal/relayer/pluginprovider/contractreader"
 	contractreadertest "github.com/smartcontractkit/chainlink-common/pkg/loop/internal/relayer/pluginprovider/contractreader/test"
+	"github.com/smartcontractkit/chainlink-common/pkg/services/servicetest"
 	"github.com/smartcontractkit/chainlink-common/pkg/types"
 	"github.com/smartcontractkit/chainlink-common/pkg/types/query"
 	"github.com/smartcontractkit/chainlink-common/pkg/types/query/primitives"
@@ -99,7 +101,7 @@ func TestBind(t *testing.T) {
 				contractreadertest.WithContractReaderLoopEncoding(version),
 			)
 
-			errTester.Setup(t)
+			errTester.Setup(t, false)
 			contractReader := errTester.GetContractReader(t)
 
 			for _, errorType := range errorTypes {
@@ -133,7 +135,7 @@ func TestGetLatestValue(t *testing.T) {
 				contractreadertest.WithContractReaderLoopEncoding(version),
 			)
 
-			errTester.Setup(t)
+			errTester.Setup(t, false)
 			contractReader := errTester.GetContractReader(t)
 
 			t.Run("nil reader should return unimplemented", func(t *testing.T) {
@@ -142,7 +144,7 @@ func TestGetLatestValue(t *testing.T) {
 				ctx := tests.Context(t)
 
 				nilTester := contractreadertest.WrapContractReaderTesterForLoop(&fakeContractReaderInterfaceTester{impl: nil})
-				nilTester.Setup(t)
+				nilTester.Setup(t, false)
 				nilCr := nilTester.GetContractReader(t)
 
 				err := nilCr.GetLatestValue(ctx, "method", primitives.Unconfirmed, "anything", "anything")
@@ -182,7 +184,7 @@ func TestBatchGetLatestValues(t *testing.T) {
 				contractreadertest.WithContractReaderLoopEncoding(version),
 			)
 
-			errTester.Setup(t)
+			errTester.Setup(t, false)
 			contractReader := errTester.GetContractReader(t)
 
 			t.Run("nil reader should return unimplemented", func(t *testing.T) {
@@ -191,7 +193,7 @@ func TestBatchGetLatestValues(t *testing.T) {
 				ctx := tests.Context(t)
 
 				nilTester := contractreadertest.WrapContractReaderTesterForLoop(&fakeContractReaderInterfaceTester{impl: nil})
-				nilTester.Setup(t)
+				nilTester.Setup(t, false)
 				nilCr := nilTester.GetContractReader(t)
 
 				_, err := nilCr.BatchGetLatestValues(ctx, types.BatchGetLatestValuesRequest{})
@@ -235,19 +237,19 @@ func TestQueryKey(t *testing.T) {
 
 			impl := &protoConversionTestContractReader{}
 			crTester := contractreadertest.WrapContractReaderTesterForLoop(&fakeContractReaderInterfaceTester{impl: impl}, contractreadertest.WithContractReaderLoopEncoding(version))
-			crTester.Setup(t)
+			crTester.Setup(t, false)
 			cr := crTester.GetContractReader(t)
 
 			es := &errContractReader{}
 			errTester := contractreadertest.WrapContractReaderTesterForLoop(&fakeContractReaderInterfaceTester{impl: es})
-			errTester.Setup(t)
+			errTester.Setup(t, false)
 			contractReader := errTester.GetContractReader(t)
 
 			t.Run("nil reader should return unimplemented", func(t *testing.T) {
 				ctx := tests.Context(t)
 
 				nilTester := contractreadertest.WrapContractReaderTesterForLoop(&fakeContractReaderInterfaceTester{impl: nil})
-				nilTester.Setup(t)
+				nilTester.Setup(t, false)
 				nilCr := nilTester.GetContractReader(t)
 
 				_, err := nilCr.QueryKey(ctx, types.BoundContract{}, query.KeyFilter{}, query.LimitAndSort{}, &[]interface{}{nil})
@@ -291,12 +293,16 @@ type fakeContractReaderInterfaceTester struct {
 	cw   fakeChainWriter
 }
 
-func (it *fakeContractReaderInterfaceTester) Setup(_ *testing.T) {
+func (it *fakeContractReaderInterfaceTester) Setup(t *testing.T, startCR bool) {
 	fake, ok := it.impl.(*fakeContractReader)
 	if ok {
 		fake.vals = []valConfidencePair{}
 		fake.triggers = []eventConfidencePair{}
 		fake.stored = []TestStruct{}
+
+		if startCR {
+			servicetest.Run(t, it.impl)
+		}
 	}
 }
 
@@ -346,8 +352,11 @@ type fakeContractReader struct {
 	stored      []TestStruct
 	batchStored BatchCallEntry
 	lock        sync.Mutex
+	isStarted   atomic.Bool
 }
 
+var errServiceNotStarted = errors.New("ContractReader service not started")
+
 type fakeChainWriter struct {
 	types.ChainWriter
 	cr *fakeContractReader
@@ -394,9 +403,15 @@ func (f *fakeChainWriter) GetFeeComponents(ctx context.Context) (*types.ChainFee
 	return &types.ChainFeeComponents{}, nil
 }
 
-func (f *fakeContractReader) Start(_ context.Context) error { return nil }
+func (f *fakeContractReader) Start(_ context.Context) error {
+	f.isStarted.Store(true)
+	return nil
+}
 
-func (f *fakeContractReader) Close() error { return nil }
+func (f *fakeContractReader) Close() error {
+	f.isStarted.Store(false)
+	return nil
+}
 
 func (f *fakeContractReader) Ready() error { panic("unimplemented") }
 
@@ -434,6 +449,10 @@ func (f *fakeContractReader) SetBatchLatestValues(batchCallEntry BatchCallEntry)
 }
 
 func (f *fakeContractReader) GetLatestValue(_ context.Context, readIdentifier string, confidenceLevel primitives.ConfidenceLevel, params, returnVal any) error {
+	if !f.isStarted.Load() {
+		return errServiceNotStarted
+	}
+
 	if strings.HasSuffix(readIdentifier, MethodReturningAlterableUint64) {
 		r := returnVal.(*uint64)
 		for i := len(f.vals) - 1; i >= 0; i-- {
@@ -508,6 +527,10 @@ func (f *fakeContractReader) GetLatestValue(_ context.Context, readIdentifier st
 }
 
 func (f *fakeContractReader) BatchGetLatestValues(_ context.Context, request types.BatchGetLatestValuesRequest) (types.BatchGetLatestValuesResult, error) {
+	if !f.isStarted.Load() {
+		return nil, errServiceNotStarted
+	}
+
 	result := make(types.BatchGetLatestValuesResult)
 	for requestContract, requestContractBatch := range request {
 		storedContractBatch := f.batchStored[requestContract]
@@ -561,6 +584,10 @@ func (f *fakeContractReader) BatchGetLatestValues(_ context.Context, request typ
 }
 
 func (f *fakeContractReader) QueryKey(_ context.Context, _ types.BoundContract, filter query.KeyFilter, limitAndSort query.LimitAndSort, _ any) ([]types.Sequence, error) {
+	if !f.isStarted.Load() {
+		return nil, errServiceNotStarted
+	}
+
 	if filter.Key == EventName {
 		f.lock.Lock()
 		defer f.lock.Unlock()
diff --git a/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go b/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
index 427552d80e..8daada26a5 100644
--- a/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
+++ b/pkg/loop/internal/relayer/pluginprovider/contractreader/test/contract_reader_loop_tester.go
@@ -59,8 +59,8 @@ type contractReaderLoopTester struct {
 	encodeWith contractreader.EncodingVersion
 }
 
-func (c *contractReaderLoopTester) Setup(t *testing.T) {
-	c.ChainComponentsInterfaceTester.Setup(t)
+func (c *contractReaderLoopTester) Setup(t *testing.T, startCR bool) {
+	c.ChainComponentsInterfaceTester.Setup(t, startCR)
 	contractReader := c.ChainComponentsInterfaceTester.GetContractReader(t)
 
 	c.lst.registerHook = func(server *grpc.Server) {
diff --git a/pkg/types/interfacetests/chain_components_interface_tests.go b/pkg/types/interfacetests/chain_components_interface_tests.go
index f6ad34d8a7..3edfa816d8 100644
--- a/pkg/types/interfacetests/chain_components_interface_tests.go
+++ b/pkg/types/interfacetests/chain_components_interface_tests.go
@@ -15,8 +15,28 @@ import (
 	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
 )
 
-type ChainComponentsInterfaceTester[T TestingT[T]] interface {
+type ChainComponentsTester[T any] interface {
 	BasicTester[T]
+	Setup(t T, startCR bool)
+}
+
+type chainComponentsTestcase[T any] struct {
+	name    string
+	test    func(t T)
+	startCR bool
+}
+
+func runChainComponentsTests[T TestingT[T]](t T, tester ChainComponentsTester[T], tests []chainComponentsTestcase[T]) {
+	for _, test := range tests {
+		t.Run(test.name+" for "+tester.Name(), func(t T) {
+			tester.Setup(t, test.startCR)
+			test.test(t)
+		})
+	}
+}
+
+type ChainComponentsInterfaceTester[T TestingT[T]] interface {
+	ChainComponentsTester[T]
 	GetContractReader(t T) types.ContractReader
 	GetChainWriter(t T) types.ChainWriter
 	GetBindings(t T) []types.BoundContract
@@ -58,17 +78,30 @@ func RunContractReaderInterfaceTests[T TestingT[T]](t T, tester ChainComponentsI
 }
 
 func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool) {
-	tests := []testcase[T]{
+	tests := []chainComponentsTestcase[T]{
 		{
-			name: "Gets the latest value",
+			name:    "Get latest value without starting service returns error",
+			startCR: false,
 			test: func(t T) {
 				ctx := tests.Context(t)
-				firstItem := CreateTestStruct(0, tester)
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
+				bound := bindingsByName(bindings, AnyContractName)[0] // minimum of one bound contract expected, otherwise panics
+				require.NoError(t, cr.Bind(ctx, tester.GetBindings(t)))
+				require.Error(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(MethodTakingLatestParamsReturningTestStruct), primitives.Unconfirmed, nil, nil))
+			},
+		},
+		{
+			name:    "Gets the latest value",
+			startCR: true,
+			test: func(t T) {
+				ctx := tests.Context(t)
+				firstItem := CreateTestStruct[T](0, tester)
 
 				contracts := tester.GetBindings(t)
 				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, firstItem, contracts[0], types.Unconfirmed)
 
-				secondItem := CreateTestStruct(1, tester)
+				secondItem := CreateTestStruct[T](1, tester)
 
 				_ = SubmitTransactionToCW(t, tester, MethodSettingStruct, secondItem, contracts[0], types.Unconfirmed)
 
@@ -90,7 +123,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value without arguments and with primitive return",
+			name:    "Get latest value without arguments and with primitive return",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -106,7 +140,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value based on confidence level",
+			name:    "Get latest value based on confidence level",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -135,7 +170,7 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 				err := WaitForTransactionStatus(t, tester, txID, types.Finalized, mockRun)
 				require.NoError(t, err)
 
-				require.NoError(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(MethodReturningAlterableUint64), primitives.Finalized, nil, &prim1))
+				require.NoError(t, cr.GetLatestValue(ctx, bound.ReadIdentifier(callArgs.ReadName), primitives.Finalized, callArgs.Params, &prim1))
 				assert.Equal(t, uint64(10), prim1)
 
 				_ = SubmitTransactionToCW(t, tester, MethodSettingUint64, PrimitiveArgs{Value: 20}, contracts[0], types.Unconfirmed)
@@ -146,7 +181,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value allows multiple contract names to have the same function name",
+			name:    "Get latest value allows multiple contract names to have the same function name",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -162,7 +198,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value without arguments and with slice return",
+			name:    "Get latest value without arguments and with slice return",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -178,10 +215,11 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value wraps config with modifiers using its own mapstructure overrides",
+			name:    "Get latest value wraps config with modifiers using its own mapstructure overrides",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
-				testStruct := CreateTestStruct(0, tester)
+				testStruct := CreateTestStruct[T](0, tester)
 				testStruct.BigField = nil
 				testStruct.Account = nil
 
@@ -196,14 +234,15 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 
 				expected := &TestStructWithExtraField{
 					ExtraField: AnyExtraValue,
-					TestStruct: CreateTestStruct(0, tester),
+					TestStruct: CreateTestStruct[T](0, tester),
 				}
 
 				assert.Equal(t, expected, actual)
 			},
 		},
 		{
-			name: "Get latest value gets latest event",
+			name:    "Get latest value gets latest event",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -227,7 +266,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest event based on provided confidence level",
+			name:    "Get latest event based on provided confidence level",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -263,7 +303,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value returns not found if event was never triggered",
+			name:    "Get latest value returns not found if event was never triggered",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -278,7 +319,8 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 		{
-			name: "Get latest value gets latest event with filtering",
+			name:    "Get latest value gets latest event with filtering",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -286,11 +328,11 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 				bound := bindingsByName(bindings, AnyContractName)[0]
 
 				require.NoError(t, cr.Bind(ctx, bindings))
-				ts0 := CreateTestStruct(0, tester)
+				ts0 := CreateTestStruct[T](0, tester)
 
 				contracts := tester.GetBindings(t)
 				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts0, contracts[0], types.Unconfirmed)
-				ts1 := CreateTestStruct(1, tester)
+				ts1 := CreateTestStruct[T](1, tester)
 				_ = SubmitTransactionToCW(t, tester, MethodTriggeringEvent, ts1, contracts[0], types.Unconfirmed)
 
 				filterParams := &FilterEventParams{Field: *ts0.Field}
@@ -309,16 +351,49 @@ func runContractReaderGetLatestValueInterfaceTests[T TestingT[T]](t T, tester Ch
 			},
 		},
 	}
-	runTests(t, tester, tests)
+	runChainComponentsTests(t, tester, tests)
 }
 
 func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], mockRun bool) {
-	testCases := []testcase[T]{
+	testCases := []chainComponentsTestcase[T]{
+		{
+			name:    "BatchGetLatestValues without starting service returns error",
+			startCR: false,
+			test: func(t T) {
+				// setup test data
+				firstItem := CreateTestStruct[T](1, tester)
+				bindings := tester.GetBindings(t)
+				bound := bindingsByName(bindings, AnyContractName)[0]
+
+				batchCallEntry := make(BatchCallEntry)
+				batchCallEntry[bound] = ContractBatchEntry{{Name: MethodTakingLatestParamsReturningTestStruct, ReturnValue: &firstItem}}
+				batchChainWrite(t, tester, batchCallEntry, mockRun)
+
+				// setup call data
+				params, actual := &LatestParams{I: 1}, &TestStruct{}
+				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
+				batchGetLatestValueRequest[bound] = []types.BatchRead{
+					{
+						ReadName:  MethodTakingLatestParamsReturningTestStruct,
+						Params:    params,
+						ReturnVal: actual,
+					},
+				}
+
+				ctx := tests.Context(t)
+				cr := tester.GetContractReader(t)
+
+				require.NoError(t, cr.Bind(ctx, tester.GetBindings(t)))
+				_, err := cr.BatchGetLatestValues(ctx, batchGetLatestValueRequest)
+				require.Error(t, err)
+			},
+		},
 		{
-			name: "BatchGetLatestValues works",
+			name:    "BatchGetLatestValues works",
+			startCR: true,
 			test: func(t T) {
 				// setup test data
-				firstItem := CreateTestStruct(1, tester)
+				firstItem := CreateTestStruct[T](1, tester)
 				bindings := tester.GetBindings(t)
 				bound := bindingsByName(bindings, AnyContractName)[0]
 
@@ -352,7 +427,8 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValues works without arguments and with primitive return",
+			name:    "BatchGetLatestValues works without arguments and with primitive return",
+			startCR: true,
 			test: func(t T) {
 				// setup call data
 				var primitiveReturnValue uint64
@@ -383,7 +459,8 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValues allows multiple contract names to have the same function Name",
+			name:    "BatchGetLatestValues allows multiple contract names to have the same function Name",
+			startCR: true,
 			test: func(t T) {
 				var primitiveReturnValueAnyContract, primitiveReturnValueAnySecondContract uint64
 				batchGetLatestValuesRequest := make(types.BatchGetLatestValuesRequest)
@@ -413,7 +490,8 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValue without arguments and with slice return",
+			name:    "BatchGetLatestValue without arguments and with slice return",
+			startCR: true,
 			test: func(t T) {
 				// setup call data
 				var sliceReturnValue []uint64
@@ -437,10 +515,11 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValues wraps config with modifiers using its own mapstructure overrides",
+			name:    "BatchGetLatestValues wraps config with modifiers using its own mapstructure overrides",
+			startCR: true,
 			test: func(t T) {
 				// setup call data
-				testStruct := CreateTestStruct(0, tester)
+				testStruct := CreateTestStruct[T](0, tester)
 				testStruct.BigField = nil
 				testStruct.Account = nil
 				actual := &TestStructWithExtraField{}
@@ -463,13 +542,14 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 				assert.Equal(t,
 					&TestStructWithExtraField{
 						ExtraField: AnyExtraValue,
-						TestStruct: CreateTestStruct(0, tester),
+						TestStruct: CreateTestStruct[T](0, tester),
 					},
 					returnValue)
 			},
 		},
 		{
-			name: "BatchGetLatestValues supports same read with different params and results retain order from request",
+			name:    "BatchGetLatestValues supports same read with different params and results retain order from request",
+			startCR: true,
 			test: func(t T) {
 				batchCallEntry := make(BatchCallEntry)
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
@@ -478,7 +558,7 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 
 				for i := 0; i < 10; i++ {
 					// setup test data
-					ts := CreateTestStruct(i, tester)
+					ts := CreateTestStruct[T](i, tester)
 					batchCallEntry[bound] = append(batchCallEntry[bound], ReadEntry{Name: MethodTakingLatestParamsReturningTestStruct, ReturnValue: &ts})
 					// setup call data
 					batchGetLatestValueRequest[bound] = append(
@@ -505,7 +585,8 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValues supports same read with different params and results retain order from request even with multiple contracts",
+			name:    "BatchGetLatestValues supports same read with different params and results retain order from request even with multiple contracts",
+			startCR: true,
 			test: func(t T) {
 				batchCallEntry := make(BatchCallEntry)
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
@@ -515,7 +596,7 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 
 				for i := 0; i < 10; i++ {
 					// setup test data
-					ts1, ts2 := CreateTestStruct(i, tester), CreateTestStruct(i+10, tester)
+					ts1, ts2 := CreateTestStruct[T](i, tester), CreateTestStruct[T](i+10, tester)
 					batchCallEntry[bound1] = append(batchCallEntry[bound1], ReadEntry{Name: MethodTakingLatestParamsReturningTestStruct, ReturnValue: &ts1})
 					batchCallEntry[bound2] = append(batchCallEntry[bound2], ReadEntry{Name: MethodTakingLatestParamsReturningTestStruct, ReturnValue: &ts2})
 					// setup call data
@@ -553,7 +634,8 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 		{
-			name: "BatchGetLatestValues sets errors properly",
+			name:    "BatchGetLatestValues sets errors properly",
+			startCR: true,
 			test: func(t T) {
 				batchGetLatestValueRequest := make(types.BatchGetLatestValuesRequest)
 				bindings := tester.GetBindings(t)
@@ -587,13 +669,27 @@ func runContractReaderBatchGetLatestValuesInterfaceTests[T TestingT[T]](t T, tes
 			},
 		},
 	}
-	runTests(t, tester, testCases)
+	runChainComponentsTests(t, tester, testCases)
 }
 
 func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T]) {
-	tests := []testcase[T]{
+	tests := []chainComponentsTestcase[T]{
+		{
+			name:    "QueryKey without starting service returns error",
+			startCR: false,
+			test: func(t T) {
+				ctx := tests.Context(t)
+				cr := tester.GetContractReader(t)
+				bindings := tester.GetBindings(t)
+				bound := bindingsByName(bindings, AnyContractName)[0]
+				require.NoError(t, cr.Bind(ctx, tester.GetBindings(t)))
+				_, err := cr.QueryKey(ctx, bound, query.KeyFilter{Key: EventName}, query.LimitAndSort{}, &TestStruct{})
+				require.Error(t, err)
+			},
+		},
 		{
-			name: "QueryKey returns not found if sequence never happened",
+			name:    "QueryKey returns not found if sequence never happened",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -609,7 +705,8 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 			},
 		},
 		{
-			name: "QueryKey returns sequence data properly",
+			name:    "QueryKey returns sequence data properly",
+			startCR: true,
 			test: func(t T) {
 				ctx := tests.Context(t)
 				cr := tester.GetContractReader(t)
@@ -633,7 +730,7 @@ func runQueryKeyInterfaceTests[T TestingT[T]](t T, tester ChainComponentsInterfa
 		},
 	}
 
-	runTests(t, tester, tests)
+	runChainComponentsTests(t, tester, tests)
 }
 
 func bindingsByName(bindings []types.BoundContract, name string) []types.BoundContract {
diff --git a/pkg/types/interfacetests/codec_interface_tests.go b/pkg/types/interfacetests/codec_interface_tests.go
index 79e53dcc14..baf1342c28 100644
--- a/pkg/types/interfacetests/codec_interface_tests.go
+++ b/pkg/types/interfacetests/codec_interface_tests.go
@@ -19,8 +19,27 @@ type EncodeRequest struct {
 	TestOn       string
 }
 
+type codecTestcase[T any] struct {
+	name string
+	test func(t T)
+}
+
+type CodecTester[T any] interface {
+	BasicTester[T]
+	Setup(t T)
+}
+
+func runCodecTests[T TestingT[T]](t T, tester CodecTester[T], tests []codecTestcase[T]) {
+	for _, test := range tests {
+		t.Run(test.name+" for "+tester.Name(), func(t T) {
+			tester.Setup(t)
+			test.test(t)
+		})
+	}
+}
+
 type CodecInterfaceTester interface {
-	BasicTester[*testing.T]
+	CodecTester[*testing.T]
 	EncodeFields(t *testing.T, request *EncodeRequest) []byte
 	GetCodec(t *testing.T) types.Codec
 
@@ -38,7 +57,7 @@ const (
 )
 
 func RunCodecInterfaceTests(t *testing.T, tester CodecInterfaceTester) {
-	tests := []testcase[*testing.T]{
+	tests := []codecTestcase[*testing.T]{
 		{
 			name: "Encodes and decodes a single item",
 			test: func(t *testing.T) {
@@ -362,7 +381,7 @@ func RunCodecInterfaceTests(t *testing.T, tester CodecInterfaceTester) {
 			},
 		},
 	}
-	runTests(t, tester, tests)
+	runCodecTests(t, tester, tests)
 }
 
 // RunCodecWithStrictArgsInterfaceTest is meant to be used by codecs that don't pad
@@ -372,7 +391,7 @@ func RunCodecInterfaceTests(t *testing.T, tester CodecInterfaceTester) {
 func RunCodecWithStrictArgsInterfaceTest(t *testing.T, tester CodecInterfaceTester) {
 	RunCodecInterfaceTests(t, tester)
 
-	tests := []testcase[*testing.T]{
+	tests := []codecTestcase[*testing.T]{
 		{
 			name: "Gives an error decoding extra fields on an item",
 			test: func(t *testing.T) {
@@ -439,5 +458,5 @@ func RunCodecWithStrictArgsInterfaceTest(t *testing.T, tester CodecInterfaceTest
 		},
 	}
 
-	runTests(t, tester, tests)
+	runCodecTests(t, tester, tests)
 }
diff --git a/pkg/types/interfacetests/utils.go b/pkg/types/interfacetests/utils.go
index 4079f5dc20..aa70329370 100644
--- a/pkg/types/interfacetests/utils.go
+++ b/pkg/types/interfacetests/utils.go
@@ -16,31 +16,16 @@ import (
 )
 
 type BasicTester[T any] interface {
-	Setup(t T)
 	Name() string
 	GetAccountBytes(i int) []byte
 }
 
-type testcase[T any] struct {
-	name string
-	test func(t T)
-}
-
 type TestingT[T any] interface {
 	tests.TestingT
 	Failed() bool
 	Run(name string, f func(t T)) bool
 }
 
-func runTests[T TestingT[T]](t T, tester BasicTester[T], tests []testcase[T]) {
-	for _, test := range tests {
-		t.Run(test.name+" for "+tester.Name(), func(t T) {
-			tester.Setup(t)
-			test.test(t)
-		})
-	}
-}
-
 // Batch chain write takes a batch call entry and writes it to the chain using the ChainWriter.
 func batchChainWrite[T TestingT[T]](t T, tester ChainComponentsInterfaceTester[T], batchCallEntry BatchCallEntry, mockRun bool) {
 	// This is necessary because the mock helper function requires the entire batchCallEntry rather than an individual testStruct