Eli Ribble
e48abb09c0
This calculates the summary information of data in h3 nodes and puts it in the database for fast lookup.
1521 lines
34 KiB
Go
1521 lines
34 KiB
Go
// Code generated by BobGen psql v0.41.1. DO NOT EDIT.
|
|
// This file is meant to be re-generated in place and/or deleted at any time.
|
|
|
|
package factory
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
)
|
|
|
|
func TestCreateFieldseekerSync(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFieldseekerSyncWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FieldseekerSync: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSContainerrelate(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSContainerrelateWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSContainerrelate: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSFieldscoutinglog(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSFieldscoutinglogWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSFieldscoutinglog: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSHabitatrelate(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSHabitatrelateWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSHabitatrelate: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSInspectionsample(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSInspectionsampleWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSInspectionsample: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSInspectionsampledetail(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSInspectionsampledetailWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSInspectionsampledetail: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSLinelocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSLinelocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSLinelocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSLocationtracking(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSLocationtrackingWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSLocationtracking: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSMosquitoinspection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSMosquitoinspectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSMosquitoinspection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSPointlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSPointlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSPointlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSPolygonlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSPolygonlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSPolygonlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSPool(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSPoolWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSPool: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSPooldetail(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSPooldetailWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSPooldetail: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSProposedtreatmentarea(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSProposedtreatmentareaWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSProposedtreatmentarea: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSQamosquitoinspection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSQamosquitoinspectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSQamosquitoinspection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSRodentlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSRodentlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSRodentlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSSamplecollection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSSamplecollectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSSamplecollection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSSamplelocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSSamplelocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSSamplelocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSServicerequest(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSServicerequestWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSServicerequest: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSSpeciesabundance(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSSpeciesabundanceWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSSpeciesabundance: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSStormdrain(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSStormdrainWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSStormdrain: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSTimecard(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSTimecardWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSTimecard: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSTrapdatum(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSTrapdatumWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSTrapdatum: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSTraplocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSTraplocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSTraplocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSTreatment(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSTreatmentWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSTreatment: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSTreatmentarea(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSTreatmentareaWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSTreatmentarea: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSZone(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSZoneWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSZone: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateFSZones2(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewFSZones2WithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating FSZones2: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateGooseDBVersion(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewGooseDBVersionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating GooseDBVersion: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateH3Aggregation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewH3AggregationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating H3Aggregation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryContainerrelate(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryContainerrelateWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryContainerrelate: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryFieldscoutinglog(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryFieldscoutinglogWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryFieldscoutinglog: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryHabitatrelate(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryHabitatrelateWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryHabitatrelate: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryInspectionsample(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryInspectionsampleWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryInspectionsample: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryInspectionsampledetail(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryInspectionsampledetailWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryInspectionsampledetail: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryLinelocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryLinelocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryLinelocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryLocationtracking(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryLocationtrackingWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryLocationtracking: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryMosquitoinspection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryMosquitoinspectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryMosquitoinspection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryPointlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryPointlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryPointlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryPolygonlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryPolygonlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryPolygonlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryPool(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryPoolWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryPool: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryPooldetail(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryPooldetailWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryPooldetail: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryProposedtreatmentarea(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryProposedtreatmentareaWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryProposedtreatmentarea: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryQamosquitoinspection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryQamosquitoinspectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryQamosquitoinspection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryRodentlocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryRodentlocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryRodentlocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistorySamplecollection(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistorySamplecollectionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistorySamplecollection: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistorySamplelocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistorySamplelocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistorySamplelocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryServicerequest(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryServicerequestWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryServicerequest: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistorySpeciesabundance(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistorySpeciesabundanceWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistorySpeciesabundance: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryStormdrain(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryStormdrainWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryStormdrain: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryTimecard(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryTimecardWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryTimecard: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryTrapdatum(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryTrapdatumWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryTrapdatum: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryTraplocation(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryTraplocationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryTraplocation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryTreatment(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryTreatmentWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryTreatment: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryTreatmentarea(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryTreatmentareaWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryTreatmentarea: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryZone(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryZoneWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryZone: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateHistoryZones2(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewHistoryZones2WithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating HistoryZones2: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateNotification(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewNotificationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating Notification: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateOauthToken(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewOauthTokenWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating OauthToken: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateOrganization(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewOrganizationWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating Organization: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateSession(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewSessionWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating Session: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateSpatialRefSy(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewSpatialRefSyWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating SpatialRefSy: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreateUser(t *testing.T) {
|
|
if testDB == nil {
|
|
t.Skip("skipping test, no DSN provided")
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(t.Context())
|
|
t.Cleanup(cancel)
|
|
|
|
tx, err := testDB.Begin(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Error starting transaction: %v", err)
|
|
}
|
|
|
|
defer func() {
|
|
if err := tx.Rollback(ctx); err != nil {
|
|
t.Fatalf("Error rolling back transaction: %v", err)
|
|
}
|
|
}()
|
|
|
|
if _, err := New().NewUserWithContext(ctx).Create(ctx, tx); err != nil {
|
|
t.Fatalf("Error creating User: %v", err)
|
|
}
|
|
}
|