Skip to content

Commit b4345a7

Browse files
JamesReateJamesReate
authored
INTG-1696 wmi mismatch handling (#283)
* test case showing failure * implement changes, database changes too
1 parent 15f7caa commit b4345a7

8 files changed

Lines changed: 211 additions & 500 deletions

File tree

‎cmd/device-definitions-api/add_vin.go‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,6 @@ import (
1717
"github.com/DIMO-Network/device-definitions-api/internal/infrastructure/sender"
1818
"github.com/ethereum/go-ethereum/ethclient"
1919

20-
"github.com/volatiletech/sqlboiler/v4/queries/qm"
21-
2220
"github.com/DIMO-Network/device-definitions-api/internal/config"
2321
"github.com/DIMO-Network/device-definitions-api/internal/infrastructure/db/models"
2422
"github.com/DIMO-Network/shared"
@@ -83,7 +81,7 @@ func (p *addVINCmd) Execute(ctx context.Context, _ *flag.FlagSet, _ ...interface
8381
return subcommands.ExitSuccess
8482
}
8583
processedVIN := shared.VIN(vin)
86-
wmi, err := models.Wmis(models.WmiWhere.Wmi.EQ(processedVIN.Wmi()), qm.Load(models.WmiRels.DeviceMake)).One(ctx, pdb.DBS().Reader)
84+
wmi, err := models.Wmis(models.WmiWhere.Wmi.EQ(processedVIN.Wmi())).One(ctx, pdb.DBS().Reader)
8785
if err != nil {
8886
fmt.Println("could not find WMI for vin")
8987
return subcommands.ExitFailure
@@ -95,7 +93,7 @@ func (p *addVINCmd) Execute(ctx context.Context, _ *flag.FlagSet, _ ...interface
9593
SerialNumber: processedVIN.SerialNumber(),
9694
CheckDigit: null.StringFrom(processedVIN.CheckDigit()),
9795
Vis: null.StringFrom(processedVIN.VIS()),
98-
ManufacturerName: wmi.R.DeviceMake.Name,
96+
ManufacturerName: wmi.ManufacturerName,
9997
DecodeProvider: null.StringFrom("manual"),
10098
Year: processedVIN.Year(),
10199
}
@@ -118,12 +116,12 @@ func (p *addVINCmd) Execute(ctx context.Context, _ *flag.FlagSet, _ ...interface
118116
return subcommands.ExitFailure
119117
}
120118

121-
manufacturer, err := onChainSvc.GetManufacturer(ctx, wmi.R.DeviceMake.NameSlug, pdb.DBS().Reader)
119+
manufacturer, err := onChainSvc.GetManufacturer(ctx, shared.SlugString(wmi.ManufacturerName), pdb.DBS().Reader)
122120
if err != nil {
123121
fmt.Println(err.Error())
124122
return subcommands.ExitFailure
125123
}
126-
definitionID := common.DeviceDefinitionSlug(wmi.R.DeviceMake.NameSlug, shared.SlugString(model), int16(vinNumber.Year))
124+
definitionID := common.DeviceDefinitionSlug(shared.SlugString(wmi.ManufacturerName), shared.SlugString(model), int16(vinNumber.Year))
127125
deviceDefinition, err := onChainSvc.GetDefinitionTableland(ctx, big.NewInt(int64(manufacturer.TokenID)), definitionID)
128126

129127
if err != nil {

‎internal/core/queries/decode_vin.go‎

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -14,8 +14,6 @@ import (
1414
"github.com/DIMO-Network/device-definitions-api/internal/infrastructure/metrics"
1515
"github.com/prometheus/client_golang/prometheus"
1616

17-
"github.com/volatiletech/sqlboiler/v4/queries/qm"
18-
1917
"github.com/DIMO-Network/device-definitions-api/internal/core/common"
2018
"github.com/DIMO-Network/device-definitions-api/internal/core/mediator"
2119
coremodels "github.com/DIMO-Network/device-definitions-api/internal/core/models"
@@ -197,12 +195,11 @@ func (dc DecodeVINQueryHandler) Handle(ctx context.Context, query mediator.Messa
197195
}
198196
// check if this is a Tesla VIN, if not just follow regular path
199197
vinInfo := &coremodels.VINDecodingInfoData{}
200-
dbWMI, err := models.Wmis(models.WmiWhere.Wmi.EQ(wmi), qm.Load(models.WmiRels.DeviceMake)).One(ctx, dc.dbs().Reader)
198+
dbWMI, err := models.Wmis(models.WmiWhere.Wmi.EQ(wmi)).One(ctx, dc.dbs().Reader)
201199
if err == nil && dbWMI != nil {
202-
if dbWMI.R.DeviceMake != nil && dbWMI.R.DeviceMake.Name == "Tesla" {
200+
if dbWMI.ManufacturerName == "Tesla" {
203201
vinInfo, err = dc.vinDecodingService.GetVIN(ctx, vin.String(), dt, coremodels.TeslaProvider, qry.Country)
204202
resp.Manufacturer = "Tesla"
205-
resp.DeviceMakeId = dbWMI.R.DeviceMake.ID //nolint
206203
}
207204
}
208205
// not a tesla, regular decode path
@@ -232,24 +229,21 @@ func (dc DecodeVINQueryHandler) Handle(ctx context.Context, query mediator.Messa
232229
// todo track failed decodes
233230
return nil, err
234231
}
235-
// todo: WMI's may be re-used by multiple OEM's of same parent OEM
236-
// we may have already gotten this above
232+
// WMI's may be re-used by multiple OEM's of same parent OEM, but just create it if needed
237233
if dbWMI == nil {
238-
dbWMI, err = dc.vinRepository.GetOrCreateWMI(ctx, wmi, vinInfo.Make)
234+
_, err = dc.vinRepository.GetOrCreateWMI(ctx, wmi, vinInfo.Make)
239235
if err != nil {
240-
metrics.InternalError.With(prometheus.Labels{"method": VinErrors}).Inc()
236+
// just log, Japan chasis numbers won't really work with this anyways
241237
dc.logger.Error().Err(err).Msgf("failed to get or create wmi for vin %s", vin.String())
242-
return resp, nil
243238
}
244239
}
245-
resp.DeviceMakeId = dbWMI.DeviceMakeID //nolint
246240
resp.Manufacturer = vinInfo.Make
247241
resp.Source = string(vinInfo.Source)
248242
resp.Year = vinInfo.Year
249243
resp.Model = vinInfo.Model
250244

251245
modelSlug := shared.SlugString(vinInfo.Model)
252-
tid := common.DeviceDefinitionSlug(dbWMI.R.DeviceMake.NameSlug, modelSlug, int16(vinInfo.Year))
246+
tid := common.DeviceDefinitionSlug(shared.SlugString(vinInfo.Make), modelSlug, int16(vinInfo.Year))
253247
resp.DefinitionId = tid
254248

255249
tblDef, _, errTbl := dc.deviceDefinitionOnChainService.GetDefinitionByID(ctx, tid, dc.dbs().Reader)
@@ -487,12 +481,14 @@ func (dc DecodeVINQueryHandler) saveVinDecodeNumber(ctx context.Context, vin sha
487481
func (dc DecodeVINQueryHandler) vinInfoFromKnown(vin shared.VIN, knownModel string, knownYear int32) (*coremodels.VINDecodingInfoData, error) {
488482
vinInfo := &coremodels.VINDecodingInfoData{}
489483
vinInfo.VIN = vin.String()
490-
wmi, err := models.Wmis(models.WmiWhere.Wmi.EQ(vin.Wmi()),
491-
qm.Load(models.WmiRels.DeviceMake)).One(context.Background(), dc.dbs().Reader)
484+
wmis, err := models.Wmis(models.WmiWhere.Wmi.EQ(vin.Wmi())).All(context.Background(), dc.dbs().Reader)
492485
if err != nil {
493486
return nil, errors.Wrap(err, "vinInfoFromKnown: could not get WMI from vin wmi "+vin.Wmi())
494487
}
495-
vinInfo.Make = wmi.R.DeviceMake.Name
488+
if len(wmis) > 1 {
489+
return nil, fmt.Errorf("vinInfoFromKnown: more than one WMI found for vin wmi %s", vin.Wmi())
490+
}
491+
vinInfo.Make = wmis[0].ManufacturerName
496492
vinInfo.Year = knownYear
497493
vinInfo.Model = knownModel
498494
vinInfo.Source = "probably smartcar"

‎internal/core/queries/decode_vin_test.go‎

Lines changed: 130 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -148,11 +148,9 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingDD_UpdatesAt
148148
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
149149
buildTestTblDD(definitionID, dd.Model, int(dd.Year)), nil, nil)
150150
wmiDb := &models.Wmi{
151-
Wmi: vin[:3],
152-
DeviceMakeID: dm.ID,
151+
Wmi: vin[:3],
152+
ManufacturerName: dm.Name,
153153
}
154-
wmiDb.R = wmiDb.R.NewStruct()
155-
wmiDb.R.DeviceMake = &dm
156154
s.mockVINRepo.EXPECT().GetOrCreateWMI(gomock.Any(), vin[:3], dm.Name).Return(wmiDb, nil)
157155

158156
image := gateways.FuelImage{
@@ -191,7 +189,121 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingDD_UpdatesAt
191189

192190
}
193191

194-
// todo two new test: WMI oem conflict, same WMI for different Make name
192+
// WMI oem conflict, same WMI for different Make name is ok. Ford WMI already exists, but decodes to Lincoln w/ same WMI
193+
func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_CreatesDD_WithMismatchWMI() {
194+
ctx := context.Background()
195+
const vin = "1FMCU0G61MUA52727" // Lincoln escape 2021
196+
const wmi = "1FM"
197+
198+
dmFord := dbtesthelper.SetupCreateMake(s.T(), "Ford", s.pdb)
199+
dmLincoln := dbtesthelper.SetupCreateMake(s.T(), "Lincoln", s.pdb)
200+
_ = dbtesthelper.SetupCreateAutoPiIntegration(s.T(), s.pdb)
201+
_ = dbtesthelper.SetupCreateWMI(s.T(), wmi, dmFord.ID, s.pdb)
202+
203+
// mock setup, include some attributes we should expect in metadata, and trim we should expect created in styles
204+
vinInfoResp := &coremodels.DrivlyVINResponse{
205+
Vin: vin,
206+
Year: "2022",
207+
Make: dmLincoln.Name,
208+
Model: "Aviator",
209+
SubModel: "Hybrid",
210+
Trim: "XLE",
211+
Generation: 4,
212+
ManufacturerCode: "1234",
213+
Drive: "AWD",
214+
Engine: "4 Cyl",
215+
EngineDetails: "16-Valve, Inline-4, GDI, Hybrid, DOHC, Atkinson Cycle 2.5 L",
216+
Doors: 4,
217+
MsrpBase: 23000,
218+
Fuel: "Hybrid",
219+
FuelTankCapacityGal: 15.5,
220+
Mpg: 25,
221+
MpgCity: 21,
222+
MpgHighway: 31,
223+
Wheelbase: "106 WB",
224+
}
225+
226+
deviceTypeInfo := make(map[string]interface{})
227+
deviceTypeInfo["mpg_city"] = vinInfoResp.MpgCity
228+
deviceTypeInfo["mpg_highway"] = vinInfoResp.MpgHighway
229+
deviceTypeInfo["mpg"] = vinInfoResp.Mpg
230+
deviceTypeInfo["base_msrp"] = vinInfoResp.MsrpBase
231+
deviceTypeInfo["fuel_tank_capacity_gal"] = vinInfoResp.FuelTankCapacityGal
232+
deviceTypeInfo["fuel_type"] = vinInfoResp.Fuel
233+
deviceTypeInfo["wheelbase"] = vinInfoResp.Wheelbase
234+
deviceTypeInfo["generation"] = vinInfoResp.Generation
235+
deviceTypeInfo["number_of_doors"] = vinInfoResp.Doors
236+
deviceTypeInfo["manufacturer_code"] = vinInfoResp.ManufacturerCode
237+
deviceTypeInfo["driven_wheels"] = vinInfoResp.Drive
238+
239+
raw, _ := json.Marshal(vinInfoResp)
240+
yr, _ := strconv.Atoi(vinInfoResp.Year)
241+
vinDecodingInfoData := &coremodels.VINDecodingInfoData{
242+
StyleName: buildStyleName(vinInfoResp),
243+
SubModel: vinInfoResp.SubModel,
244+
Make: vinInfoResp.Make,
245+
Source: "drivly",
246+
Year: int32(yr),
247+
Model: vinInfoResp.Model,
248+
Raw: raw,
249+
}
250+
definitionID := "lincoln_aviator_2022"
251+
metaDataInfo := make(map[string]interface{})
252+
metaDataInfo["vehicle_info"] = deviceTypeInfo
253+
metaData, _ := json.Marshal(metaDataInfo)
254+
vinDecodingInfoData.MetaData = null.JSONFrom(metaData)
255+
256+
styleLevelPT := "PHEV"
257+
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
258+
nil, nil, nil) // should return nil b/c doesn't exist
259+
s.mockVINService.EXPECT().GetVIN(ctx, vin, gomock.Any(), coremodels.AllProviders, "USA").Times(1).Return(vinDecodingInfoData, nil)
260+
s.mockPowerTrainTypeService.EXPECT().ResolvePowerTrainFromVinInfo(vinDecodingInfoData.StyleName, vinDecodingInfoData.FuelType).Return(styleLevelPT)
261+
262+
trxHashHex := "0xa90868fe9364dbf41695b3b87e630f6455cfd63a4711f56b64f631b828c02b35"
263+
s.mockDeviceDefinitionOnChainService.EXPECT().Create(ctx, dmLincoln.Name, gomock.Any()).Return(&trxHashHex, nil)
264+
265+
image := gateways.FuelImage{
266+
SourceURL: "https://image",
267+
}
268+
fuelDeviceImagesMock := gateways.FuelDeviceImages{
269+
FuelAPIID: "1",
270+
Height: 1,
271+
Width: 1,
272+
Images: []gateways.FuelImage{image},
273+
}
274+
s.mockFuelAPIService.EXPECT().FetchDeviceImages(vinInfoResp.Make, vinInfoResp.Model, 2022, gomock.Any(), gomock.Any()).Times(2).Return(fuelDeviceImagesMock, nil)
275+
276+
qryResult, err := s.queryHandler.Handle(s.ctx, &DecodeVINQuery{VIN: vin, Country: country})
277+
s.NoError(err)
278+
result := qryResult.(*p_grpc.DecodeVinResponse)
279+
s.NotNil(result, "expected result not nil")
280+
281+
// validate style was created
282+
ds, err := models.DeviceStyles().One(s.ctx, s.pdb.DBS().Reader)
283+
s.Require().NoError(err)
284+
s.Assert().Equal(ds.ID, result.DeviceStyleId)
285+
s.Assert().Equal(vinInfoResp.Trim+" "+vinInfoResp.SubModel, ds.Name)
286+
s.Assert().Equal(vinInfoResp.SubModel, ds.SubModel)
287+
s.Assert().Equal("drivly", ds.Source)
288+
s.Assert().Equal(ds.ExternalStyleID, shared.SlugString(vinInfoResp.Trim+" "+vinInfoResp.SubModel))
289+
s.Assert().Equal(styleLevelPT, gjson.GetBytes(ds.Metadata.JSON, common.PowerTrainType).Str)
290+
// validate vin number was create
291+
vn, err := models.VinNumbers().One(s.ctx, s.pdb.DBS().Reader)
292+
require.NoError(s.T(), err)
293+
s.Assert().True(vn.DrivlyData.Valid)
294+
s.Assert().Equal(2022, vn.Year)
295+
s.Assert().Equal(definitionID, vn.DefinitionID)
296+
s.Assert().Equal(wmi, vn.Wmi.String)
297+
s.Assert().Equal("drivly", vn.DecodeProvider.String)
298+
s.Assert().Equal(vin, vn.Vin)
299+
s.Assert().Equal(dmLincoln.Name, vn.ManufacturerName)
300+
s.Assert().Equal(vinInfoResp.Model, gjson.GetBytes(vn.DrivlyData.JSON, "model").String())
301+
302+
// validate images was created
303+
ddImages, err := models.Images(models.ImageWhere.DefinitionID.EQ(definitionID)).All(s.ctx, s.pdb.DBS().Reader)
304+
s.Require().NoError(err)
305+
s.Assert().NotEmpty(ddImages)
306+
}
195307

196308
// Japan
197309
func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_JapanChassisNumber_existingVIN() {
@@ -303,12 +415,6 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_CreatesDD() {
303415

304416
trxHashHex := "0xa90868fe9364dbf41695b3b87e630f6455cfd63a4711f56b64f631b828c02b35"
305417
s.mockDeviceDefinitionOnChainService.EXPECT().Create(ctx, gomock.Any(), gomock.Any()).Return(&trxHashHex, nil)
306-
wmiDb := &models.Wmi{
307-
Wmi: vin[:3],
308-
DeviceMakeID: dm.ID,
309-
}
310-
wmiDb.R = wmiDb.R.NewStruct()
311-
wmiDb.R.DeviceMake = &dm
312418

313419
image := gateways.FuelImage{
314420
SourceURL: "https://image",
@@ -436,11 +542,9 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingDD_AndStyleA
436542
}
437543
s.mockFuelAPIService.EXPECT().FetchDeviceImages(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(2).Return(fuelDeviceImagesMock, nil)
438544
wmiDb := &models.Wmi{
439-
Wmi: vin[:3],
440-
DeviceMakeID: dm.ID,
545+
Wmi: vin[:3],
546+
ManufacturerName: dm.Name,
441547
}
442-
wmiDb.R = wmiDb.R.NewStruct()
443-
wmiDb.R.DeviceMake = &dm
444548
s.mockVINRepo.EXPECT().GetOrCreateWMI(gomock.Any(), vin[:3], dm.Name).Return(wmiDb, nil)
445549

446550
qryResult, err := s.queryHandler.Handle(s.ctx, &DecodeVINQuery{VIN: vin, Country: country})
@@ -463,8 +567,8 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingWMI() {
463567
dm := dbtesthelper.SetupCreateMake(s.T(), "Ford", s.pdb)
464568
dd := dbtesthelper.SetupCreateDeviceDefinitionWithVehicleInfo(s.T(), dm, "Escape", 2021, s.pdb)
465569
wmi := models.Wmi{
466-
Wmi: "1FM",
467-
DeviceMakeID: dm.ID,
570+
Wmi: "1FM",
571+
ManufacturerName: dm.Name,
468572
}
469573
err := wmi.Insert(s.ctx, s.pdb.DBS().Writer, boil.Infer())
470574
s.Require().NoError(err)
@@ -518,12 +622,6 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingWMI() {
518622
s.mockPowerTrainTypeService.EXPECT().ResolvePowerTrainFromVinInfo(vinDecodingInfoData.StyleName, vinDecodingInfoData.FuelType).Return("HEV")
519623
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
520624
buildTestTblDD(definitionID, dd.Model, int(dd.Year)), nil, nil)
521-
wmiDb := &models.Wmi{
522-
Wmi: vin[:3],
523-
DeviceMakeID: dm.ID,
524-
}
525-
wmiDb.R = wmiDb.R.NewStruct()
526-
wmiDb.R.DeviceMake = &dm
527625

528626
image := gateways.FuelImage{
529627
SourceURL: "https://image",
@@ -558,8 +656,8 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_TeslaDecode() {
558656
dm := dbtesthelper.SetupCreateMake(s.T(), "Tesla", s.pdb)
559657
dd := dbtesthelper.SetupCreateDeviceDefinitionWithVehicleInfo(s.T(), dm, "Model 3", 2023, s.pdb)
560658
wmi := models.Wmi{
561-
Wmi: "5YJ",
562-
DeviceMakeID: dm.ID,
659+
Wmi: "5YJ",
660+
ManufacturerName: dm.Name,
563661
}
564662
err := wmi.Insert(s.ctx, s.pdb.DBS().Writer, boil.Infer())
565663
s.Require().NoError(err)
@@ -577,12 +675,6 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_TeslaDecode() {
577675
s.mockPowerTrainTypeService.EXPECT().ResolvePowerTrainFromVinInfo(vinDecodingInfoData.StyleName, vinDecodingInfoData.FuelType).Return("BEV")
578676
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
579677
buildTestTblDD(definitionID, dd.Model, dd.Year), nil, nil)
580-
wmiDb := &models.Wmi{
581-
Wmi: vin[:3],
582-
DeviceMakeID: dm.ID,
583-
}
584-
wmiDb.R = wmiDb.R.NewStruct()
585-
wmiDb.R.DeviceMake = &dm
586678

587679
image := gateways.FuelImage{
588680
SourceURL: "https://image",
@@ -616,8 +708,8 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_WithExistingVINNumber()
616708
dm := dbtesthelper.SetupCreateMake(s.T(), "Ford", s.pdb)
617709
dd := dbtesthelper.SetupCreateDeviceDefinitionWithVehicleInfo(s.T(), dm, "Escape", 2021, s.pdb)
618710
wmi := models.Wmi{
619-
Wmi: "1FM",
620-
DeviceMakeID: dm.ID,
711+
Wmi: "1FM",
712+
ManufacturerName: dm.Name,
621713
}
622714
err := wmi.Insert(s.ctx, s.pdb.DBS().Writer, boil.Infer())
623715
s.Require().NoError(err)
@@ -682,11 +774,9 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_InvalidVINYear_AutoIso()
682774
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
683775
buildTestTblDD(definitionID, "Escape", 2021), nil, nil)
684776
wmiDb := &models.Wmi{
685-
Wmi: vin[:3],
686-
DeviceMakeID: dm.ID,
777+
Wmi: vin[:3],
778+
ManufacturerName: dm.Name,
687779
}
688-
wmiDb.R = wmiDb.R.NewStruct()
689-
wmiDb.R.DeviceMake = &dm
690780
s.mockVINRepo.EXPECT().GetOrCreateWMI(gomock.Any(), vin[:3], dm.Name).Return(wmiDb, nil)
691781

692782
image := gateways.FuelImage{
@@ -726,11 +816,9 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_InvalidStyleName_AutoIso
726816
s.mockDeviceDefinitionOnChainService.EXPECT().GetDefinitionByID(gomock.Any(), definitionID, gomock.Any()).Return(
727817
buildTestTblDD(definitionID, "Escape", 2017), nil, nil)
728818
wmiDb := &models.Wmi{
729-
Wmi: vin[:3],
730-
DeviceMakeID: dm.ID,
819+
Wmi: vin[:3],
820+
ManufacturerName: dm.Name,
731821
}
732-
wmiDb.R = wmiDb.R.NewStruct()
733-
wmiDb.R.DeviceMake = &dm
734822
s.mockVINRepo.EXPECT().GetOrCreateWMI(gomock.Any(), vin[:3], dm.Name).Return(wmiDb, nil)
735823

736824
image := gateways.FuelImage{
@@ -776,7 +864,7 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_DecodeKnownFallback() {
776864

777865
_ = dbtesthelper.SetupCreateAutoPiIntegration(s.T(), s.pdb)
778866
dm := dbtesthelper.SetupCreateMake(s.T(), "Ford", s.pdb)
779-
_ = dbtesthelper.SetupCreateWMI(s.T(), "1FM", dm.ID, s.pdb)
867+
_ = dbtesthelper.SetupCreateWMI(s.T(), "1FM", dm.Name, s.pdb)
780868

781869
definitionID := "ford_bronco_2022"
782870
s.mockVINService.EXPECT().GetVIN(ctx, vin, gomock.Any(), coremodels.AllProviders, "USA").Times(1).Return(nil, fmt.Errorf("unable to decode"))
@@ -795,12 +883,6 @@ func (s *DecodeVINQueryHandlerSuite) TestHandle_Success_DecodeKnownFallback() {
795883
Images: []gateways.FuelImage{image},
796884
}
797885
s.mockFuelAPIService.EXPECT().FetchDeviceImages(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(2).Return(fuelDeviceImagesMock, nil)
798-
wmiDb := &models.Wmi{
799-
Wmi: vin[:3],
800-
DeviceMakeID: dm.ID,
801-
}
802-
wmiDb.R = wmiDb.R.NewStruct()
803-
wmiDb.R.DeviceMake = &dm
804886

805887
qryResult, err := s.queryHandler.Handle(s.ctx, &DecodeVINQuery{VIN: vin, Country: country,
806888
KnownYear: 2022,

0 commit comments

Comments
 (0)