601 lines
14 KiB
Go
601 lines
14 KiB
Go
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)
|
|
}
|