admin/cloud-services
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial cloud-services repo - gateway service + pkg modules

Browse Source
This commit is contained in:
Chris Rai
2026-01-30 23:14:52 -05:00
commit fbb820d7b3
1037 changed files with 171318 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

600
pkg/db/queries/cars_test.go Normal file
View File

@@ -0,0 +1,600 @@
package queries_test
import (
"fmt"
"strings"
"testing"
"github.com/go-pg/pg/v10/orm"
m "fiskerinc.com/modules/common"
"fiskerinc.com/modules/db"
"fiskerinc.com/modules/db/queries"
"fiskerinc.com/modules/testhelper"
"github.com/go-pg/pg/v10"
"github.com/google/uuid"
"fiskerinc.com/modules/utils/elptr"
)
const testCarVIN = "1GNGC26R1XJ407649"
const testCarVIN2 = "1GNGC26R1XJ407648"
var qc queries.CarsInterface
var conn *pg.DB
var testCarID string
var testDriverID string
func TestCarsIntegration(t *testing.T) {
t.Skip()
defer testCarDelete(t, testCarVIN)
defer testCarDelete(t, testCarVIN2)
setupCarsTests()
clearTestCar()
testCarInsert(t, testCarVIN)
testCarInsert(t, testCarVIN2)
testCarECU(t)
testCarAddDriver(t)
testCarSelectByVIN(t)
testCarSelect(t)
testCarUpdate(t)
testSetSetting(t)
testCarSearch(t)
testGetModels(t)
testGetYears(t)
testSelectCarToDriver(t)
testGetCarsForDriver(t)
testGetCount(t)
testCarVINsSearch(t)
}
func setupCarsTests() {
instance := &queries.Cars{}
conn = instance.GetDBConn()
conn.AddQueryHook(db.SQLLogger{})
qc = instance
client := instance.GetClient()
client.InitSchema([]interface{}{
(*m.CarECU)(nil),
(*m.Car)(nil),
(*m.Driver)(nil),
(*m.CarToDriver)(nil),
(*m.CarSetting)(nil),
})
}
func testCarECU(t *testing.T) {
ecu := m.CarECU{
VIN: testCarVIN,
ECU: "ECU1",
Version: "1002",
}
err := qc.UpdateCarECU(&ecu)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "UpdateCarECU insert", "No error", err)
}
ecu.Version = "1000"
err = qc.UpdateCarECU(&ecu)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "UpdateCarECU2 update", "No error", err)
}
car := m.Car{
VIN: testCarVIN,
}
err = qc.Load(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "UpdateCarECU2 update", "No error", err)
}
if !strings.Contains(car.ECUList, "ECU1 1000") {
t.Errorf(testhelper.TestErrorTemplate, "UpdateCarECU2 update", "ECU1 1001", car.ECUList)
}
}
func testCarSearch(t *testing.T) {
search := m.CarSearch{
Search: testCarVIN,
}
options := queries.PageQueryOptions{
Offset: 0,
Limit: 0,
Order: "vin DESC",
}
result, err := qc.Search(&search, &options)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Car Search", "No error", err)
}
if len(result) != 1 {
t.Errorf(testhelper.TestErrorTemplate, "Car Search result", 1, len(result))
}
}
func testCarVINsSearch(t *testing.T) {
search := m.CarSearch{
VINs: testCarVIN + "," + testCarVIN2,
}
options := queries.PageQueryOptions{
Offset: 0,
Limit: 0,
Order: "vin DESC",
}
result, err := qc.Search(&search, &options)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Car Search", "No error", err)
}
if len(result) != 2 {
t.Errorf(testhelper.TestErrorTemplate, "Car Search result", 2, len(result))
}
}
func testSetSetting(t *testing.T) {
setting := m.CarSetting{
VIN: testCarVIN,
DriverID: testDriverID,
Name: "TestSetting",
Value: "TestValue",
}
result, err := qc.SetSetting(&setting)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "testSetSetting", result, err)
}
}
func testCarInsert(t *testing.T, vin string) {
car := m.Car{
VIN: vin,
Model: "Ocean",
Year: 2022,
Trim: "Base",
}
_, err := qc.Insert(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "SelectOrInsert", "nil", err)
}
testCarID = car.VIN
}
func testCarAddDriver(t *testing.T) {
car := m.Car{
VIN: testCarVIN,
}
drivers := []m.Driver{
{
ID: "TEST-001",
},
{
ID: "TEST-002",
},
}
_, err := qc.AddDriver(&car, &m.Driver{}, "driver")
if err == nil {
t.Errorf(testhelper.TestErrorTemplate, "AddDriver errored", "Error", err)
}
qc.Load(&car)
for _, driver := range drivers {
_, err = conn.Model(&driver).Where("id = ?id").SelectOrInsert()
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Insert driver", "nil", err)
}
_, err := qc.AddDriver(&car, &driver, "driver")
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "AddDriver", "nil", err)
}
testDriverID = driver.ID
_, err = qc.AddDriver(&car, &driver, "driverX")
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "AddDriver", "nil", err)
}
}
qc.Load(&car)
if len(car.Drivers) != 2 {
t.Errorf(testhelper.TestErrorTemplate, "Added drivers", 2, len(car.Drivers))
}
}
func testCarSelectByVIN(t *testing.T) {
car, err := qc.SelectByVIN(testCarVIN)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "SelectByID error", "nil", err)
}
if car.VIN != testCarVIN {
t.Errorf(testhelper.TestErrorTemplate, "VIN", testCarVIN, car.VIN)
}
err = qc.Load(car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Load error", "nil", err)
}
if len(car.Drivers) != 2 {
t.Errorf(testhelper.TestErrorTemplate, "Drivers", 2, len(car.Drivers))
}
}
func testCarSelect(t *testing.T) {
car := m.Car{
Year: 2022,
}
options := queries.PageQueryOptions{
Offset: 0,
Limit: 0,
Order: "vin DESC",
}
cars, err := qc.Select(&car, &options)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Select error", "nil", err)
}
count := len(cars)
if count == 0 {
t.Errorf(testhelper.TestErrorTemplate, "Count", "more than 0", len(cars))
}
options.Offset = count
options.Limit = 10
cars, err = qc.Select(&car, &options)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Select error", "nil", err)
}
if len(cars) != 0 {
t.Errorf(testhelper.TestErrorTemplate, "Count", 0, len(cars))
}
}
func testCarUpdate(t *testing.T) {
car := m.Car{
VIN: testCarVIN,
}
err := qc.Load(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Load", "nil", err)
}
car.Year = 2020
car.Model = "Ocean S"
car.Trim = "Sport"
result, err := qc.Update(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Update", "nil", err)
}
if result.RowsAffected() != 1 {
t.Errorf(testhelper.TestErrorTemplate, "Update RowsAffected", 1, result.RowsAffected())
}
car = m.Car{
VIN: testCarVIN,
}
err = qc.Load(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Reload", "nil", err)
}
if car.Year != 2020 {
t.Errorf(testhelper.TestErrorTemplate, "Update Year", 2020, car.Year)
}
if car.Model != "Ocean S" {
t.Errorf(testhelper.TestErrorTemplate, "Update Model", "Ocean S", car.Model)
}
if !car.CreatedAt.Before(*car.UpdatedAt) {
t.Errorf(testhelper.TestErrorTemplate, "UpdatedAt", car.CreatedAt, car.UpdatedAt)
}
}
func testCarDelete(t *testing.T, vin string) {
car := m.Car{
Year: 2022,
}
_, err := qc.Delete(&car)
if err == nil {
t.Errorf(testhelper.TestErrorTemplate, "No ID", "No ID error", err)
}
car = m.Car{
VIN: vin,
}
carVIN := car.VIN
_, err = qc.Delete(&car)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Delete", "nil", err)
}
cardrivers := []m.CarToDriver{}
count, err := conn.Model(&cardrivers).Where("vin = ?", carVIN).SelectAndCount()
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Count", "nil", err)
}
if count > 0 {
t.Errorf(testhelper.TestErrorTemplate, "Count", 0, count)
}
}
func testGetModels(t *testing.T) {
models, err := qc.GetModels()
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "GetModels", "nil", err)
}
if len(models) == 0 {
t.Errorf(testhelper.TestErrorTemplate, "Models Count", "More than 0", len(models))
}
}
func testGetYears(t *testing.T) {
years, err := qc.GetYears()
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "GetYears", "nil", err)
}
if len(years) == 0 {
t.Errorf(testhelper.TestErrorTemplate, "Years Count", "More than 0", len(years))
}
}
func testSelectCarToDriver(t *testing.T) {
filter := m.CarToDriver{
DriverID: "TEST-001",
}
drivers, err := qc.SelectCarToDriver(&filter)
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "SelectCarToDriver", "nil", err)
} else if len(drivers) == 0 {
t.Errorf(testhelper.TestErrorTemplate, "SelectCarToDriver", "nil", err)
}
}
func testGetCarsForDriver(t *testing.T) {
carToDrivers, err := qc.GetCarsForDriver("TEST-001")
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "GetCarsForDriver", nil, err)
}
if len(carToDrivers) == 0 {
t.Errorf(testhelper.TestErrorTemplate, "Car to Drivers Count", "More than 0", len(carToDrivers))
}
}
func testGetCount(t *testing.T) {
count, err := qc.Count(&m.Car{VIN: testCarVIN})
if err != nil {
t.Errorf(testhelper.TestErrorTemplate, "Count", nil, err)
}
if count != 1 {
t.Errorf(testhelper.TestErrorTemplate, "Count", 1, count)
}
}
func clearTestCar() {
car := m.Car{
VIN: testCarVIN,
}
result, err := conn.Model(&car).Where("vin = ?vin").Delete()
fmt.Println(result, err)
}
func TestSelectCarToDriver(t *testing.T) {
t.Skip()
cars := queries.Cars{}
rel, err := cars.AddDriver(&m.Car{VIN: "1G1FP87S3GN100062"}, &m.Driver{ID: "ddf34966-9677-46de-b2eb-ddf501968ea5"}, "role")
if err != nil {
t.Error(err)
return
}
defer cars.RemoveDriver(rel.VIN, rel.DriverID)
subtypes := queries.SubscriptionTypes{}
subtype := m.SubscriptionType{
Name: fmt.Sprintf("test %v", uuid.New()),
Description: "this is a test",
Destination: "ICC",
Currency: "USD",
Price: 0,
DurationValue: 1,
DurationUnit: "Hours",
}
_, err = subtypes.Insert(&subtype)
if err != nil {
t.Error(err)
return
}
defer subtypes.Delete(&subtype)
subs := queries.Subscriptions{}
sub, err := subs.Create(&subtype, rel)
if err != nil {
t.Error(err)
return
}
defer subs.Delete(&queries.SubscriptionDeleteRequest{ID: sub.ID})
setting := m.CarSetting{VIN: testCarVIN, DriverID: testDriverID, Name: "test123", Value: "XXXX"}
_, err = cars.SetSetting(&setting)
if err != nil {
t.Error(err)
return
}
defer cars.DeleteSetting(&setting)
carToDrivers, err := cars.SelectCarToDriver(&m.CarToDriver{VIN: rel.VIN, DriverID: rel.DriverID})
if err != nil {
t.Error(err)
return
}
if len(carToDrivers) != 1 {
t.Errorf(testhelper.TestErrorTemplate, "SelectCarToDriver count", 1, len(carToDrivers))
return
}
if len(carToDrivers[0].Settings) != 1 {
t.Errorf(testhelper.TestErrorTemplate, "SelectCarToDriver settings", 1, len(carToDrivers))
}
if len(carToDrivers[0].Subscriptions) != 1 {
t.Errorf(testhelper.TestErrorTemplate, "SelectCarToDriver settings", 1, len(carToDrivers))
}
}
func queryToString(q *orm.Query) string {
value, _ := q.AppendQuery(orm.NewFormatter(), nil)
return string(value)
}
func Test_addOnlineFilter(t *testing.T) {
type args struct {
query *orm.Query
filter *m.CarSearch
}
tests := []struct {
name string
args args
expect string
}{
{
name: "empty filter",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{},
},
expect: "SELECT *",
},
{
name: "filter with online true but no online cars",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(true),
VINsOnline: []string{},
}},
},
expect: "SELECT * WHERE (vin IN (''))",
},
{
name: "filter with hmi online true but no online cars",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
HMI: elptr.ElPtr(true),
VINsOnline: []string{},
}},
},
expect: "SELECT * WHERE (vin IN (''))",
},
{
name: "filter with online false",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(false),
}},
},
expect: "SELECT * WHERE (vin NOT IN (''))",
},
{
name: "filter with hmi online false",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(false),
}},
},
expect: "SELECT * WHERE (vin NOT IN (''))",
},
{
name: "filter with one of them being true 1",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{
Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(true),
HMI: elptr.ElPtr(false),
},
},
},
expect: "SELECT * WHERE (vin IN (''))",
},
{
name: "filter with one of them being true 2",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{
Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(false),
HMI: elptr.ElPtr(true),
},
},
},
expect: "SELECT * WHERE (vin IN (''))",
},
{
name: "filter with online true",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(true),
VINsOnline: []string{"1G1FP87S3GN100062", "1G1FP87S3GN100063"},
}},
},
expect: "SELECT * WHERE (vin IN ('1G1FP87S3GN100062','1G1FP87S3GN100063'))",
},
{
name: "filter with hmi online true",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(true),
VINsOnline: []string{"1G1FP87S3GN100064", "1G1FP87S3GN100065"},
}},
},
expect: "SELECT * WHERE (vin IN ('1G1FP87S3GN100064','1G1FP87S3GN100065'))",
},
{
name: "filter with both being online true",
args: args{
query: new(orm.Query),
filter: &m.CarSearch{Online: &m.CarOnlineFilter{
Online: elptr.ElPtr(true),
HMI: elptr.ElPtr(true),
VINsOnline: []string{
"1G1FP87S3GN100064",
"1G1FP87S3GN100065",
"1G1FP87S3GN100062",
"1G1FP87S3GN100063"},
}}},
expect: "SELECT * WHERE (vin IN ('1G1FP87S3GN100064','1G1FP87S3GN100065','1G1FP87S3GN100062','1G1FP87S3GN100063'))",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
queries.AddOnlineFilter(tt.args.query, tt.args.filter)
if got := queryToString(tt.args.query); got != tt.expect {
t.Errorf("addOnlineFilter() = %v, want %v", got, tt.expect)
}
})
}
}
func TestMeLocal(t *testing.T) {
instance := &queries.Cars{}
conn = instance.GetDBConn()
certificat := &queries.Certificates{}
//certificat.SetClient(conn)
cert, err := certificat.SelectMostRecent("p", "j")
t.Log(err)
t.Log(cert)
}