chore: use suite assertions instead of package assertions

ocpp1.6_test/authorize_test.go

@@ -6,34 +6,29 @@ import (
 
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/core"
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/types"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 // Test
 func (suite *OcppV16TestSuite) TestAuthorizeRequestValidation() {
-	t := suite.T()
 	var requestTable = []GenericTestEntry{
 		{core.AuthorizeRequest{IdTag: "12345"}, true},
 		{core.AuthorizeRequest{}, false},
 		{core.AuthorizeRequest{IdTag: ">20.................."}, false},
 	}
-	ExecuteGenericTestTable(t, requestTable)
+	ExecuteGenericTestTable(suite, requestTable)
 }
 
 func (suite *OcppV16TestSuite) TestAuthorizeConfirmationValidation() {
-	t := suite.T()
 	var confirmationTable = []GenericTestEntry{
 		{core.AuthorizeConfirmation{IdTagInfo: &types.IdTagInfo{ExpiryDate: types.NewDateTime(time.Now().Add(time.Hour * 8)), ParentIdTag: "00000", Status: types.AuthorizationStatusAccepted}}, true},
 		{core.AuthorizeConfirmation{IdTagInfo: &types.IdTagInfo{Status: "invalidAuthorizationStatus"}}, false},
 		{core.AuthorizeConfirmation{}, false},
 	}
-	ExecuteGenericTestTable(t, confirmationTable)
+	ExecuteGenericTestTable(suite, confirmationTable)
 }
 
 func (suite *OcppV16TestSuite) TestAuthorizeE2EMocked() {
-	t := suite.T()
 	wsId := "test_id"
 	messageId := defaultMessageId
 	wsUrl := "someUrl"
@@ -52,22 +47,22 @@ func (suite *OcppV16TestSuite) TestAuthorizeE2EMocked() {
 	coreListener := &MockCentralSystemCoreListener{}
 	coreListener.On("OnAuthorize", mock.AnythingOfType("string"), mock.Anything).Return(authorizeConfirmation, nil).Run(func(args mock.Arguments) {
 		request, ok := args.Get(1).(*core.AuthorizeRequest)
-		require.True(t, ok)
-		require.NotNil(t, request)
-		assert.Equal(t, idTag, request.IdTag)
+		suite.Require().True(ok)
+		suite.Require().NotNil(request)
+		suite.Equal(idTag, request.IdTag)
 	})
 	setupDefaultCentralSystemHandlers(suite, coreListener, expectedCentralSystemOptions{clientId: wsId, rawWrittenMessage: responseRaw, forwardWrittenMessage: true})
 	setupDefaultChargePointHandlers(suite, nil, expectedChargePointOptions{serverUrl: wsUrl, clientId: wsId, createChannelOnStart: true, channel: channel, rawWrittenMessage: requestRaw, forwardWrittenMessage: true})
 	// Run Test
 	suite.centralSystem.Start(8887, "somePath")
 	err := suite.chargePoint.Start(wsUrl)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	confirmation, err := suite.chargePoint.Authorize(idTag)
-	require.Nil(t, err)
-	require.NotNil(t, confirmation)
-	assert.Equal(t, status, confirmation.IdTagInfo.Status)
-	assert.Equal(t, parentIdTag, confirmation.IdTagInfo.ParentIdTag)
-	assertDateTimeEquality(t, *expiryDate, *confirmation.IdTagInfo.ExpiryDate)
+	suite.Require().Nil(err)
+	suite.Require().NotNil(confirmation)
+	suite.Equal(status, confirmation.IdTagInfo.Status)
+	suite.Equal(parentIdTag, confirmation.IdTagInfo.ParentIdTag)
+	assertDateTimeEquality(suite, *expiryDate, *confirmation.IdTagInfo.ExpiryDate)
 }
 
 func (suite *OcppV16TestSuite) TestAuthorizeInvalidEndpoint() {

ocpp1.6_test/boot_notification_test.go

@@ -6,14 +6,11 @@ import (
 
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/core"
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/types"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 // Tests
 func (suite *OcppV16TestSuite) TestBootNotificationRequestValidation() {
-	t := suite.T()
 	var requestTable = []GenericTestEntry{
 		{core.BootNotificationRequest{ChargePointModel: "test", ChargePointVendor: "test"}, true},
 		{core.BootNotificationRequest{ChargeBoxSerialNumber: "test", ChargePointModel: "test", ChargePointSerialNumber: "number", ChargePointVendor: "test", FirmwareVersion: "version", Iccid: "test", Imsi: "test"}, true},
@@ -29,11 +26,10 @@ func (suite *OcppV16TestSuite) TestBootNotificationRequestValidation() {
 		{core.BootNotificationRequest{ChargePointModel: "test", ChargePointVendor: "test", MeterSerialNumber: ">25......................."}, false},
 		{core.BootNotificationRequest{ChargePointModel: "test", ChargePointVendor: "test", MeterType: ">25......................."}, false},
 	}
-	ExecuteGenericTestTable(t, requestTable)
+	ExecuteGenericTestTable(suite, requestTable)
 }
 
 func (suite *OcppV16TestSuite) TestBootNotificationConfirmationValidation() {
-	t := suite.T()
 	var confirmationTable = []GenericTestEntry{
 		{core.BootNotificationConfirmation{CurrentTime: types.NewDateTime(time.Now()), Interval: 60, Status: core.RegistrationStatusAccepted}, true},
 		{core.BootNotificationConfirmation{CurrentTime: types.NewDateTime(time.Now()), Interval: 60, Status: core.RegistrationStatusPending}, true},
@@ -44,11 +40,10 @@ func (suite *OcppV16TestSuite) TestBootNotificationConfirmationValidation() {
 		{core.BootNotificationConfirmation{CurrentTime: types.NewDateTime(time.Now()), Interval: 60}, false},
 		{core.BootNotificationConfirmation{Interval: 60, Status: core.RegistrationStatusAccepted}, false},
 	}
-	ExecuteGenericTestTable(t, confirmationTable)
+	ExecuteGenericTestTable(suite, confirmationTable)
 }
 
 func (suite *OcppV16TestSuite) TestBootNotificationE2EMocked() {
-	t := suite.T()
 	wsId := "test_id"
 	messageId := "1234"
 	wsUrl := "someUrl"
@@ -65,23 +60,23 @@ func (suite *OcppV16TestSuite) TestBootNotificationE2EMocked() {
 	coreListener := &MockCentralSystemCoreListener{}
 	coreListener.On("OnBootNotification", mock.AnythingOfType("string"), mock.Anything).Return(bootNotificationConfirmation, nil).Run(func(args mock.Arguments) {
 		request, ok := args.Get(1).(*core.BootNotificationRequest)
-		require.True(t, ok)
-		require.NotNil(t, request)
-		assert.Equal(t, chargePointModel, request.ChargePointModel)
-		assert.Equal(t, chargePointVendor, request.ChargePointVendor)
+		suite.Require().True(ok)
+		suite.Require().NotNil(request)
+		suite.Equal(chargePointModel, request.ChargePointModel)
+		suite.Equal(chargePointVendor, request.ChargePointVendor)
 	})
 	setupDefaultCentralSystemHandlers(suite, coreListener, expectedCentralSystemOptions{clientId: wsId, rawWrittenMessage: []byte(responseJson), forwardWrittenMessage: true})
 	setupDefaultChargePointHandlers(suite, nil, expectedChargePointOptions{serverUrl: wsUrl, clientId: wsId, createChannelOnStart: true, channel: channel, rawWrittenMessage: []byte(requestJson), forwardWrittenMessage: true})
 	// Run test
 	suite.centralSystem.Start(8887, "somePath")
 	err := suite.chargePoint.Start(wsUrl)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	confirmation, err := suite.chargePoint.BootNotification(chargePointModel, chargePointVendor)
-	require.Nil(t, err)
-	require.NotNil(t, confirmation)
-	assert.Equal(t, registrationStatus, confirmation.Status)
-	assert.Equal(t, interval, confirmation.Interval)
-	assertDateTimeEquality(t, *currentTime, *confirmation.CurrentTime)
+	suite.Require().Nil(err)
+	suite.Require().NotNil(confirmation)
+	suite.Equal(registrationStatus, confirmation.Status)
+	suite.Equal(interval, confirmation.Interval)
+	assertDateTimeEquality(suite, *currentTime, *confirmation.CurrentTime)
 }
 
 func (suite *OcppV16TestSuite) TestBootNotificationInvalidEndpoint() {

ocpp1.6_test/cancel_reservation_test.go

@@ -4,34 +4,29 @@ import (
 	"fmt"
 
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/reservation"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 // Test
 func (suite *OcppV16TestSuite) TestCancelReservationRequestValidation() {
-	t := suite.T()
 	requestTable := []GenericTestEntry{
 		{reservation.CancelReservationRequest{ReservationId: 42}, true},
 		{reservation.CancelReservationRequest{}, true},
 		{reservation.CancelReservationRequest{ReservationId: -1}, true},
 	}
-	ExecuteGenericTestTable(t, requestTable)
+	ExecuteGenericTestTable(suite, requestTable)
 }
 
 func (suite *OcppV16TestSuite) TestCancelReservationConfirmationValidation() {
-	t := suite.T()
 	confirmationTable := []GenericTestEntry{
 		{reservation.CancelReservationConfirmation{Status: reservation.CancelReservationStatusAccepted}, true},
 		{reservation.CancelReservationConfirmation{Status: "invalidCancelReservationStatus"}, false},
 		{reservation.CancelReservationConfirmation{}, false},
 	}
-	ExecuteGenericTestTable(t, confirmationTable)
+	ExecuteGenericTestTable(suite, confirmationTable)
 }
 
 func (suite *OcppV16TestSuite) TestCancelReservationE2EMocked() {
-	t := suite.T()
 	wsId := "test_id"
 	messageId := defaultMessageId
 	wsUrl := "someUrl"
@@ -45,27 +40,27 @@ func (suite *OcppV16TestSuite) TestCancelReservationE2EMocked() {
 	reservationListener := &MockChargePointReservationListener{}
 	reservationListener.On("OnCancelReservation", mock.Anything).Return(cancelReservationConfirmation, nil).Run(func(args mock.Arguments) {
 		request, ok := args.Get(0).(*reservation.CancelReservationRequest)
-		require.NotNil(t, request)
-		require.True(t, ok)
-		assert.Equal(t, reservationId, request.ReservationId)
+		suite.Require().NotNil(request)
+		suite.Require().True(ok)
+		suite.Equal(reservationId, request.ReservationId)
 	})
 	setupDefaultCentralSystemHandlers(suite, nil, expectedCentralSystemOptions{clientId: wsId, rawWrittenMessage: []byte(requestJson), forwardWrittenMessage: true})
 	setupDefaultChargePointHandlers(suite, nil, expectedChargePointOptions{serverUrl: wsUrl, clientId: wsId, createChannelOnStart: true, channel: channel, rawWrittenMessage: []byte(responseJson), forwardWrittenMessage: true})
 	suite.chargePoint.SetReservationHandler(reservationListener)
 	// Run Test
 	suite.centralSystem.Start(8887, "somePath")
 	err := suite.chargePoint.Start(wsUrl)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	resultChannel := make(chan bool, 1)
 	err = suite.centralSystem.CancelReservation(wsId, func(confirmation *reservation.CancelReservationConfirmation, err error) {
-		require.Nil(t, err)
-		require.NotNil(t, confirmation)
-		assert.Equal(t, status, confirmation.Status)
+		suite.Require().Nil(err)
+		suite.Require().NotNil(confirmation)
+		suite.Equal(status, confirmation.Status)
 		resultChannel <- true
 	}, reservationId)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	result := <-resultChannel
-	assert.True(t, result)
+	suite.True(result)
 }
 
 func (suite *OcppV16TestSuite) TestCancelReservationInvalidEndpoint() {

ocpp1.6_test/certificate_signed_test.go

@@ -5,32 +5,28 @@ import (
 
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/security"
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6_test/mocks"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 func (suite *OcppV16TestSuite) TestCertificateSignedRequestValidation() {
-	t := suite.T()
 	var testTable = []GenericTestEntry{
 		{security.CertificateSignedRequest{CertificateChain: "sampleCert"}, true},
 		{security.CertificateSignedRequest{CertificateChain: ""}, false},
 		{security.CertificateSignedRequest{}, false},
 		{security.CertificateSignedRequest{CertificateChain: newLongString(100001)}, false},
 	}
-	ExecuteGenericTestTable(t, testTable)
+	ExecuteGenericTestTable(suite, testTable)
 }
 
 func (suite *OcppV16TestSuite) TestCertificateSignedConfirmationValidation() {
-	t := suite.T()
 	var testTable = []GenericTestEntry{
 		{security.CertificateSignedResponse{Status: security.CertificateSignedStatusAccepted}, true},
 		{security.CertificateSignedResponse{Status: security.CertificateSignedStatusAccepted}, true},
 		{security.CertificateSignedResponse{Status: security.CertificateSignedStatusRejected}, true},
 		{security.CertificateSignedResponse{Status: "invalidCertificateSignedStatus"}, false},
 		{security.CertificateSignedResponse{}, false},
 	}
-	ExecuteGenericTestTable(t, testTable)
+	ExecuteGenericTestTable(suite, testTable)
 }
 
 // Test
@@ -49,7 +45,7 @@ func (suite *OcppV16TestSuite) TestCertificateSignedE2EMocked() {
 	// Setting handlers
 	handler := mocks.NewMockSecurityChargePointHandler(t)
 	handler.EXPECT().OnCertificateSigned(mock.Anything).RunAndReturn(func(request *security.CertificateSignedRequest) (*security.CertificateSignedResponse, error) {
-		assert.Equal(t, certificateChain, request.CertificateChain)
+		suite.Equal(certificateChain, request.CertificateChain)
 		return certificateSignedConfirmation, nil
 	})
 
@@ -60,19 +56,19 @@ func (suite *OcppV16TestSuite) TestCertificateSignedE2EMocked() {
 	suite.centralSystem.Start(8887, "somePath")
 	suite.chargePoint.SetSecurityHandler(handler)
 	err := suite.chargePoint.Start(wsUrl)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	resultChannel := make(chan bool, 1)
 	err = suite.centralSystem.CertificateSigned(wsId, func(confirmation *security.CertificateSignedResponse, err error) {
-		require.Nil(t, err)
-		require.NotNil(t, confirmation)
-		assert.Equal(t, status, confirmation.Status)
+		suite.Require().Nil(err)
+		suite.Require().NotNil(confirmation)
+		suite.Equal(status, confirmation.Status)
 		resultChannel <- true
 	}, certificateChain, func(request *security.CertificateSignedRequest) {
 		request.CertificateChain = certificateChain
 	})
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	result := <-resultChannel
-	assert.True(t, result)
+	suite.True(result)
 }
 
 func (suite *OcppV16TestSuite) TestCertificateSignedInvalidEndpoint() {

ocpp1.6_test/change_availability_test.go

@@ -4,13 +4,10 @@ import (
 	"fmt"
 
 	"github.com/lorenzodonini/ocpp-go/ocpp1.6/core"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
 )
 
 func (suite *OcppV16TestSuite) TestChangeAvailabilityRequestValidation() {
-	t := suite.T()
 	var testTable = []GenericTestEntry{
 		{core.ChangeAvailabilityRequest{ConnectorId: 0, Type: core.AvailabilityTypeOperative}, true},
 		{core.ChangeAvailabilityRequest{ConnectorId: 0, Type: core.AvailabilityTypeInoperative}, true},
@@ -19,24 +16,22 @@ func (suite *OcppV16TestSuite) TestChangeAvailabilityRequestValidation() {
 		{core.ChangeAvailabilityRequest{Type: "invalidAvailabilityType"}, false},
 		{core.ChangeAvailabilityRequest{ConnectorId: -1, Type: core.AvailabilityTypeOperative}, false},
 	}
-	ExecuteGenericTestTable(t, testTable)
+	ExecuteGenericTestTable(suite, testTable)
 }
 
 func (suite *OcppV16TestSuite) TestChangeAvailabilityConfirmationValidation() {
-	t := suite.T()
 	var testTable = []GenericTestEntry{
 		{core.ChangeAvailabilityConfirmation{Status: core.AvailabilityStatusAccepted}, true},
 		{core.ChangeAvailabilityConfirmation{Status: core.AvailabilityStatusRejected}, true},
 		{core.ChangeAvailabilityConfirmation{Status: core.AvailabilityStatusScheduled}, true},
 		{core.ChangeAvailabilityConfirmation{Status: "invalidAvailabilityStatus"}, false},
 		{core.ChangeAvailabilityConfirmation{}, false},
 	}
-	ExecuteGenericTestTable(t, testTable)
+	ExecuteGenericTestTable(suite, testTable)
 }
 
 // Test
 func (suite *OcppV16TestSuite) TestChangeAvailabilityE2EMocked() {
-	t := suite.T()
 	wsId := "test_id"
 	messageId := defaultMessageId
 	wsUrl := "someUrl"
@@ -51,27 +46,27 @@ func (suite *OcppV16TestSuite) TestChangeAvailabilityE2EMocked() {
 	coreListener := &MockChargePointCoreListener{}
 	coreListener.On("OnChangeAvailability", mock.Anything).Return(changeAvailabilityConfirmation, nil).Run(func(args mock.Arguments) {
 		request, ok := args.Get(0).(*core.ChangeAvailabilityRequest)
-		require.NotNil(t, request)
-		require.True(t, ok)
-		assert.Equal(t, connectorId, request.ConnectorId)
-		assert.Equal(t, availabilityType, request.Type)
+		suite.Require().NotNil(request)
+		suite.Require().True(ok)
+		suite.Equal(connectorId, request.ConnectorId)
+		suite.Equal(availabilityType, request.Type)
 	})
 	setupDefaultCentralSystemHandlers(suite, nil, expectedCentralSystemOptions{clientId: wsId, rawWrittenMessage: []byte(requestJson), forwardWrittenMessage: true})
 	setupDefaultChargePointHandlers(suite, coreListener, expectedChargePointOptions{serverUrl: wsUrl, clientId: wsId, createChannelOnStart: true, channel: channel, rawWrittenMessage: []byte(responseJson), forwardWrittenMessage: true})
 	// Run Test
 	suite.centralSystem.Start(8887, "somePath")
 	err := suite.chargePoint.Start(wsUrl)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	resultChannel := make(chan bool, 1)
 	err = suite.centralSystem.ChangeAvailability(wsId, func(confirmation *core.ChangeAvailabilityConfirmation, err error) {
-		require.NotNil(t, confirmation)
-		require.Nil(t, err)
-		assert.Equal(t, status, confirmation.Status)
+		suite.Require().NotNil(confirmation)
+		suite.Require().Nil(err)
+		suite.Equal(status, confirmation.Status)
 		resultChannel <- true
 	}, connectorId, availabilityType)
-	require.Nil(t, err)
+	suite.Require().Nil(err)
 	result := <-resultChannel
-	assert.True(t, result)
+	suite.True(result)
 }
 
 func (suite *OcppV16TestSuite) TestChangeAvailabilityInvalidEndpoint() {