dsunit

type BaseResponse struct {
	Status  string
	Message string
}

type CheckSchemaRequest struct {
	Source           *SchemaTarget
	Dest             *SchemaTarget
	Tables           []string
	CheckNullables   bool
	CheckPrimaryKeys bool
}

type CheckSchemaResponse struct {
	*BaseResponse
	Tables []*SchemaTableCheck
	*assertly.Validation
}

type CompareRequest struct {
	Source1           *DatastoreSQL
	Source2           *DatastoreSQL
	Directives        map[string]interface{}
	Ignore            []string // columns to ignore
	OmitEmpty         bool
	MaxRowDiscrepancy int //max discrepant rows
}

type CompareResponse struct {
	*BaseResponse
	Dataset1Count int
	Dataset2Count int
	MatchedRows   int
	*assertly.Validation
}

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 DatastoreSQL struct {
	Datastore string
	SQL       string
}

type DumpRequest struct {
	Datastore string   `description:"registered datastore i.e. db1"`
	Tables    []string `description:"tables, all if empty"`
	DestURL   string   `description:"represent dataset destination"`
	Target    string   `description:"target vendor, use only if different than source"`
	/*
		mapping url content should represents a map between source and dest data (all data type should be upper case) type i.e

		{
			"INT": "BIGINT",
			"INTEGER":   "BIGINT",
			"NUMERIC":   "DECIMAL(7,2)",
			"FLOAT":   "DECIMAL(7,2)",
			"VARCHAR":   "VARCHAR(255)",
			"STRING":   "VARCHAR(255)",
			"CHAR":      "VARCHAR(255)",
			"DATE":      "DATE",
			"TIMESTAMP": "TIMESTAMP",
		},

	*/
	MappingURL string `description:"if target driver is used - you can provide data type mapping"`
}

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"`
	LocationTimezone string            `description:"convert time to specified timezone i.e UTC"`
	Override         map[string]string `description:"overrides column with supplied values"`
	ASCII            []string          `description:"column values to be ascii sanitized"`
	RelativeDate     []string          `description:"transform date to date expr"`
	Obfuscation      []Obfuscation     `description:"obfuscation rules"`
	Reset            bool              `description:"add extra empty record to truncate before inserting"`
	TimeFormat       string            `description:"java/ios based time format"`
	TimeLayout       string            `description:"golang based time layout"`
}

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 Obfuscation struct {
	Columns       []string
	Method        ObfuscationMethod
	DictionaryURL string
	Dictionary    []string
	Key           *kms.Key
	IDKey         string
	Template      string
}

type ObfuscationMethod string

type PingRequest struct {
	Datastore string
	TimeoutMs int
}

type PingResponse struct {
	*BaseResponse
}

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
	Expect      []map[string]interface{} `description:"if specified validation would take place"`
}

type QueryResponse struct {
	*BaseResponse
	Records Records
	*assertly.Validation
}

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"`
	PingRequest `json:",inline" yaml:",inline"`
	Ping        bool `description:"flag to wait for database get online"`
}

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   []*dsurl.Resource
}

type SchemaTableCheck struct {
	Table string
	*assertly.Validation
}

type SchemaTarget struct {
	Datastore  string `description:"datastore"`
	Target     string `description:"target vendor, use only if different than source"`
	MappingURL string `description:"if target driver is used - you can provide data type mapping"`
}

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

	//Compare compares data produces by specified SQLs
	Compare(request *CompareRequest) *CompareResponse

	//CheckSchema checks source and dest schema
	CheckSchema(request *CheckSchemaRequest) *CheckSchemaResponse

	//Ping waits until if database is online or error
	Ping(request *PingRequest) *PingResponse

	SetContext(context toolbox.Context)
}

type Tester interface {

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

	// RegisterFromURL 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

	// RecreateFromURL 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

	// RunSQLFromURL 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

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

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

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

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

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

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

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

	// PopulateWithURL populates database with datasets, JSON requests are fetched from files in directory
	PopulateWithURL(t *testing.T, URL string, datastore string, datasets ...*Dataset) 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

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

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

	// ExpectWithURL verifies datastore with supplied expected datasets, JSON requests are fetched from files in directory
	ExpectWithURL(t *testing.T, checkPolicy int, URL string, datastore string, datasets ...*Dataset) 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

	// Ping waits until database is online or error
	Ping(t *testing.T, datastore string, timeoutMs int) bool
}