dsunit

type BaseResponse struct {
	Status  string
	Message string
}

type DatafileInfo struct {
	Filename string
	Name     string
	Ext      string
	Prefix   string
	Postfix  string
}

type Dataset struct {
	Table   string  `required:"true"`
	Records Records `required:"true"`
}

type DatasetResource struct {
	*url.Resource      ` description:"data file location, csv, json, ndjson formats are supported"`
	*DatastoreDatasets `required:"true" description:"datastore datasets"`
	Prefix             string ` description:"location data file prefix"`  //apply prefix
	Postfix            string ` description:"location data file postgix"` //apply suffix
	// contains filtered or unexported fields
}

type DatasetValidation struct {
	Dataset string
	*assertly.Validation
	Expected interface{}
	Actual   interface{}
}

type DatastoreDatasets struct {
	Datastore string                              `required:"true" description:"register datastore"`
	Datasets  []*Dataset                          `description:"collection of dataset per table"`
	Data      map[string][]map[string]interface{} `description:"map, where each pair represent table name and records (backwad compatiblity)"`
}

type DumpRequest struct {
	Datastore string   `description:"registered datastore i.e. db1"`
	Tables    []string `description:"tables, all if empty"`
	DestURL   string   `description:"represent dataset destination"`
}

type DumpResponse struct {
	*BaseResponse
	Count   int
	DestURL string
}

type ExpectRequest struct {
	*DatasetResource
	CheckPolicy int `required:"true" description:"0 - FullTableDatasetCheckPolicy, 1 - SnapshotDatasetCheckPolicy"`
}

type ExpectResponse struct {
	*BaseResponse
	Validation  []*DatasetValidation
	PassedCount int
	FailedCount int
}

type FreezeRequest struct {
	Datastore string            `description:"registered datastore i.e. db1"`
	SQL       string            `description:"dataset SQL soruce"`
	DestURL   string            `description:"represent dataset destination"`
	OmitEmpty bool              `description:"flag to skip empty attributes"`
	Ignore    []string          `description:"path to ignore i.e. request.postbody"`
	Replace   map[string]string `description:"key of path with corresponding replacement value"`
}

type FreezeResponse struct {
	*BaseResponse
	Count   int
	DestURL string
}

type InitRequest struct {
	Datastore string
	Recreate  bool
	*RegisterRequest
	Admin *RegisterRequest
	*MappingRequest
	*RunScriptRequest
}

type InitResponse struct {
	*BaseResponse
	Tables []string
}

type Mapper struct {
	// contains filtered or unexported fields
}

type Mapping struct {
	*url.Resource
	*MappingTable
	Name string `required:"true" description:"mapping name (i.e view name)"`
}

type MappingColumn struct {
	Name         string `required:"true" description:"column name"`
	DefaultValue string
	FromColumn   string `description:"if specified it defined value source for this column"`
	Required     bool   `description:"table record will be mapped if values for all required columns are present"`
	Unique       bool   `description:"flag key/s that are unique"`
}

type MappingRequest struct {
	Mappings []*Mapping `required:"true" description:"virtual table mapping"`
}

type MappingResponse struct {
	*BaseResponse
	Tables []string
}

type MappingTable struct {
	Table   string           `required:"true"`
	Columns []*MappingColumn `required:"true"`

	Associations []*MappingTable
}

type ModificationInfo struct {
	Subject  string
	Method   string `description:"modification method determined by presence of primary key: load - insert, persist: insert or update"`
	Deleted  int
	Modified int
	Added    int
}

type PrepareRequest struct {
	Expand           bool `description:"substitute $ expression with content of context.state"`
	*DatasetResource `required:"true" description:"datasets resource"`
}

type PrepareResponse struct {
	*BaseResponse
	Expand       bool                         `description:"substitute $ expression with content of context.state"`
	Modification map[string]*ModificationInfo `description:"modification info by subject"`
}

type QueryRequest struct {
	Datastore   string
	SQL         string
	IgnoreError bool
}

type QueryResponse struct {
	*BaseResponse
	Records Records
}

type Record map[string]interface{}

type Records []map[string]interface{}

type RecreateRequest struct {
	Datastore      string `` /* 157-byte string literal not displayed */
	AdminDatastore string `description:"database  used to run DDL"`
}

type RecreateResponse struct {
	*BaseResponse
}

type RegisterRequest struct {
	Datastore string                 `required:"true" description:"datastore name"`
	Config    *dsc.Config            `description:"datastore config"`
	ConfigURL string                 `description:"datastore config URL"`
	Tables    []*dsc.TableDescriptor `description:"optional table descriptors"`
}

type RegisterResponse struct {
	*BaseResponse
}

type RunSQLRequest struct {
	Datastore string `required:"true" description:"registered datastore name"`
	Expand    bool   `description:"substitute $ expression with content of context.state"`
	SQL       []string
}

type RunSQLResponse struct {
	*BaseResponse
	RowsAffected int
}

type RunScriptRequest struct {
	Datastore string `required:"true" description:"registered datastore name"`
	Expand    bool   `description:"substitute $ expression with content of context.state"`
	Scripts   []*url.Resource
}

type SequenceRequest struct {
	Datastore string
	Tables    []string
}

type SequenceResponse struct {
	*BaseResponse
	Sequences map[string]int
}

type Service interface {
	//Registry returns registry of registered database managers
	Registry() dsc.ManagerRegistry

	//Register registers new datastore connection
	Register(request *RegisterRequest) *RegisterResponse

	//Recreate remove and creates datastore
	Recreate(request *RecreateRequest) *RecreateResponse

	//RunSQL runs supplied SQL
	RunSQL(request *RunSQLRequest) *RunSQLResponse

	//RunScript runs supplied SQL scripts
	RunScript(request *RunScriptRequest) *RunSQLResponse

	//Add table mapping
	AddTableMapping(request *MappingRequest) *MappingResponse

	//Init datastore, (register, recreated, run sql, add mapping)
	Init(request *InitRequest) *InitResponse

	//Populate database with datasets
	Prepare(request *PrepareRequest) *PrepareResponse

	//Verify datastore with supplied expected datasets
	Expect(request *ExpectRequest) *ExpectResponse

	//Query returns query from database
	Query(request *QueryRequest) *QueryResponse

	//Sequence returns sequence for supplied tables
	Sequence(request *SequenceRequest) *SequenceResponse

	//Freeze creates a dataset from existing database/datastore (reverse engineering test setup/verification)
	Freeze(request *FreezeRequest) *FreezeResponse

	//Dump creates a database schema from existing database for supplied tables, datastore
	Dump(request *DumpRequest) *DumpResponse

	SetContext(context toolbox.Context)
}

type Tester interface {

	//Register registers new datastore connection
	Register(t *testing.T, request *RegisterRequest) bool

	//Register registers new datastore connection, JSON request is fetched from URL
	RegisterFromURL(t *testing.T, URL string) bool

	//Recreate recreates datastore
	Recreate(t *testing.T, request *RecreateRequest) bool

	//Recreate recreates datastore, JSON request is fetched from URL
	RecreateFromURL(t *testing.T, URL string) bool

	//RunSQL runs supplied SQL
	RunSQL(t *testing.T, request *RunSQLRequest) bool

	//RunSQL runs supplied SQL, JSON request is fetched from URL
	RunSQLFromURL(t *testing.T, URL string) bool

	//RunScript runs supplied SQL scripts
	RunScript(t *testing.T, request *RunScriptRequest) bool

	//RunScript runs supplied SQL scripts, JSON request is fetched from URL
	RunScriptFromURL(t *testing.T, URL string) bool

	//Add table mapping
	AddTableMapping(t *testing.T, request *MappingRequest) bool

	//Add table mapping, JSON request is fetched from URL
	AddTableMappingFromURL(t *testing.T, URL string) bool

	//Init datastore, (register, recreated, run sql, add mapping)
	Init(t *testing.T, request *InitRequest) bool

	//Init datastore, (register, recreated, run sql, add mapping), JSON request is fetched from URL
	InitFromURL(t *testing.T, URL string) bool

	//Populate database with datasets
	Prepare(t *testing.T, request *PrepareRequest) bool

	//Populate database with datasets, JSON request is fetched from URL
	PrepareFromURL(t *testing.T, URL string) bool

	//PrepareDatastore matches all dataset files that are in the same location as a test file, with the same test file prefix, followed by lowe camel case test name.
	PrepareDatastore(t *testing.T, datastore string) bool

	//PrepareFor matches all dataset files that are located in baseDirectory with method name and
	// populate datastore with all listed dataset
	// Note the matchable dataset files in the base directory have the following naming:
	//
	//  <lower_underscore method name>_populate_<table>.[json|csv]
	//  To prepare dataset to populate datastore table: 'users' and 'permissions' for test method ReadAll you would
	//  have you create the following files in the baseDirectory
	//
	//  read_all_prepare_travelers2.json
	//  read_all_populate_permissions.json
	//
	PrepareFor(t *testing.T, datastore string, baseDirectory string, method string) bool

	//Verify datastore with supplied expected datasets
	Expect(t *testing.T, request *ExpectRequest) bool

	//Verify datastore with supplied expected datasets, JSON request is fetched from URL
	ExpectFromURL(t *testing.T, URL string) bool

	//ExpectDatasets matches all dataset files that are located in the same directory as the test file with method name to
	//verify that all listed dataset values are present in datastore
	ExpectDatasets(t *testing.T, datastore string, checkPolicy int) bool

	//ExpectFor matches all dataset files that are located in baseDirectory with method name to
	// verify that all listed dataset values are present in datastore
	// Note the matchable dataset files in the base directory have the following naming:
	//
	//  <lower_underscore method name>_expect_<table>.[json|csv]
	//  To prepare expected dataset table: 'users' and 'permissions' for test method ReadAll you would
	//  have you create the following files in the baseDirectory
	//
	//  read_all_expect_users.json
	//  read_all_expect_permissions.json
	//
	ExpectFor(t *testing.T, datastore string, checkPolicy int, baseDirectory string, method string) bool
}