contracts

package
v0.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 20, 2025 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ArticleContracts = []Contract{
	{
		Name:        "ListArticles",
		Description: "List all articles for a ticket",
		Method:      "GET",
		Path:        "/api/v1/tickets/1/articles",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{
				Required: true,
				Properties: map[string]Schema{
					"articles": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
						"id":        NumberSchema{Required: true},
						"ticket_id": NumberSchema{Required: true},
						"subject":   StringSchema{},
						"body":      StringSchema{},
					}}},
					"total": NumberSchema{},
				},
			},
		},
	},
	{
		Name:        "GetArticle",
		Description: "Get single article by ID",
		Method:      "GET",
		Path:        "/api/v1/tickets/1/articles/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":        NumberSchema{Required: true},
				"ticket_id": NumberSchema{Required: true},
				"subject":   StringSchema{},
				"body":      StringSchema{},
			}},
		},
	},
	{
		Name:        "GetArticleWithAttachments",
		Description: "Get article with attachment information",
		Method:      "GET",
		Path:        "/api/v1/tickets/1/articles/1?include_attachments=true",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":        NumberSchema{Required: true},
				"ticket_id": NumberSchema{Required: true},
				"subject":   StringSchema{},
				"body":      StringSchema{},
				"attachments": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"id":           NumberSchema{Required: true},
					"filename":     StringSchema{Required: true},
					"content_type": StringSchema{},
					"size":         NumberSchema{},
				}}}},
			},
		},
	},
	{
		Name:        "CreateArticle",
		Description: "Create new article for ticket",
		Method:      "POST",
		Path:        "/api/v1/tickets/1/articles",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"subject":      "Test Article",
			"body":         "This is a test article body",
			"from_email":   "agent@example.com",
			"to_email":     "customer@example.com",
			"article_type": "email-external",
			"sender_type":  "agent",
			"is_visible":   true,
		},
		Expected: Response{
			Status: http.StatusCreated,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":        NumberSchema{Required: true},
				"ticket_id": NumberSchema{Required: true},
				"subject":   StringSchema{},
				"body":      StringSchema{},
			}},
		},
	},
	{
		Name:        "UpdateArticle",
		Description: "Update existing article",
		Method:      "PUT",
		Path:        "/api/v1/tickets/1/articles/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"subject": "Updated Article Subject",
			"body":    "Updated article body content",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":        NumberSchema{Required: true},
				"ticket_id": NumberSchema{Required: true},
				"subject":   StringSchema{},
				"body":      StringSchema{},
			}},
		},
	},
	{
		Name:        "DeleteArticle",
		Description: "Delete article from ticket",
		Method:      "DELETE",
		Path:        "/api/v1/tickets/1/articles/2",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"message": StringSchema{},
				"id":      NumberSchema{},
			}},
		},
	},
}

ArticleContracts defines the API contracts for article endpoints

View Source 
var PriorityContracts = []Contract{
	{
		Name:        "ListPriorities",
		Description: "List all priorities",
		Method:      "GET",
		Path:        "/api/v1/priorities",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"priorities": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"id":       NumberSchema{Required: true},
					"name":     StringSchema{Required: true},
					"valid_id": NumberSchema{},
				}}, Required: true},
				"total": NumberSchema{},
			}},
		},
	},
	{
		Name:        "GetPriority",
		Description: "Get single priority by ID",
		Method:      "GET",
		Path:        "/api/v1/priorities/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":       NumberSchema{Required: true},
				"name":     StringSchema{Required: true},
				"valid_id": NumberSchema{},
			}},
		},
	},
	{
		Name:        "CreatePriority",
		Description: "Create new priority",
		Method:      "POST",
		Path:        "/api/v1/priorities",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name": "Test Priority",
		},
		Expected: Response{
			Status: http.StatusCreated,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":       NumberSchema{Required: true},
				"name":     StringSchema{Required: true},
				"valid_id": NumberSchema{},
			}},
		},
	},
	{
		Name:        "UpdatePriority",
		Description: "Update existing priority",
		Method:      "PUT",
		Path:        "/api/v1/priorities/6",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name": "Updated Priority",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":       NumberSchema{Required: true},
				"name":     StringSchema{Required: true},
				"valid_id": NumberSchema{},
			}},
		},
	},
	{
		Name:        "DeletePriority",
		Description: "Soft delete priority",
		Method:      "DELETE",
		Path:        "/api/v1/priorities/10",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"message": StringSchema{},
				"id":      NumberSchema{},
			}},
		},
	},
}

PriorityContracts defines the API contracts for priority endpoints

View Source 
var QueueContracts = []Contract{
	{
		Name:        "ListQueues",
		Description: "List all queues",
		Method:      "GET",
		Path:        "/api/v1/queues",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"queues": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"id":          NumberSchema{Required: true},
					"name":        StringSchema{Required: true},
					"description": StringSchema{},
					"valid_id":    NumberSchema{},
				}}, Required: true},
				"total": NumberSchema{},
			}},
		},
	},
	{
		Name:        "GetQueue",
		Description: "Get single queue by ID",
		Method:      "GET",
		Path:        "/api/v1/queues/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":          NumberSchema{Required: true},
				"name":        StringSchema{Required: true},
				"description": StringSchema{},
				"valid_id":    NumberSchema{},
			}},
		},
	},
	{
		Name:        "CreateQueue",
		Description: "Create new queue",
		Method:      "POST",
		Path:        "/api/v1/queues",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name":         "Test Queue",
			"description":  "Test queue description",
			"group_access": []int{1, 2},
		},
		Expected: Response{
			Status: http.StatusCreated,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":          NumberSchema{Required: true},
				"name":        StringSchema{Required: true},
				"description": StringSchema{},
				"valid_id":    NumberSchema{},
			}},
		},
	},
	{
		Name:        "UpdateQueue",
		Description: "Update existing queue",
		Method:      "PUT",
		Path:        "/api/v1/queues/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name":        "Updated Queue",
			"description": "Updated description",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":          NumberSchema{Required: true},
				"name":        StringSchema{Required: true},
				"description": StringSchema{},
				"valid_id":    NumberSchema{},
			}},
		},
	},
	{
		Name:        "DeleteQueue",
		Description: "Soft delete queue",
		Method:      "DELETE",
		Path:        "/api/v1/queues/10",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"message": StringSchema{},
				"id":      NumberSchema{},
			}},
		},
	},
}

QueueContracts defines the API contracts for queue endpoints

View Source 
var SLAContracts = []Contract{
	{
		Name:        "ListSLAs",
		Description: "List all SLAs",
		Method:      "GET",
		Path:        "/api/v1/slas",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"slas": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"id":                  NumberSchema{Required: true},
					"name":                StringSchema{Required: true},
					"first_response_time": NumberSchema{},
					"solution_time":       NumberSchema{},
					"valid_id":            NumberSchema{},
				}}, Required: true},
				"total": NumberSchema{},
			}},
		},
	},
	{
		Name:        "GetSLA",
		Description: "Get single SLA by ID",
		Method:      "GET",
		Path:        "/api/v1/slas/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":                  NumberSchema{Required: true},
				"name":                StringSchema{Required: true},
				"first_response_time": NumberSchema{},
				"solution_time":       NumberSchema{},
				"valid_id":            NumberSchema{},
			}},
		},
	},
	{
		Name:        "CreateSLA",
		Description: "Create new SLA",
		Method:      "POST",
		Path:        "/api/v1/slas",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name":                  "Test SLA",
			"calendar_id":           1,
			"first_response_time":   60,
			"first_response_notify": 50,
			"update_time":           120,
			"update_notify":         100,
			"solution_time":         480,
			"solution_notify":       400,
		},
		Expected: Response{
			Status: http.StatusCreated,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":                  NumberSchema{Required: true},
				"name":                StringSchema{Required: true},
				"first_response_time": NumberSchema{},
				"solution_time":       NumberSchema{},
				"valid_id":            NumberSchema{},
			}},
		},
	},
	{
		Name:        "UpdateSLA",
		Description: "Update existing SLA",
		Method:      "PUT",
		Path:        "/api/v1/slas/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name":                "Updated SLA",
			"first_response_time": 45,
			"solution_time":       360,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":                  NumberSchema{Required: true},
				"name":                StringSchema{Required: true},
				"first_response_time": NumberSchema{},
				"solution_time":       NumberSchema{},
			}},
		},
	},
	{
		Name:        "DeleteSLA",
		Description: "Soft delete SLA",
		Method:      "DELETE",
		Path:        "/api/v1/slas/10",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"message": StringSchema{},
				"id":      NumberSchema{},
			}},
		},
	},
	{
		Name:        "SLAMetrics",
		Description: "Get SLA performance metrics",
		Method:      "GET",
		Path:        "/api/v1/slas/1/metrics",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"sla_id":   NumberSchema{Required: true},
				"sla_name": StringSchema{},
				"metrics":  ObjectSchema{},
			}},
		},
	},
}

SLAContracts defines the API contracts for SLA endpoints

View Source 
var SearchContracts = []Contract{
	{
		Name:        "SearchAll",
		Description: "Search across all entity types",
		Method:      "POST",
		Path:        "/api/v1/search",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"query": "network issue",
			"types": []string{"ticket", "article", "customer"},
			"limit": 10,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"query":      StringSchema{},
				"total_hits": NumberSchema{},
				"took_ms":    NumberSchema{},
				"hits":       ArraySchema{},
			}},
		},
	},
	{
		Name:        "SearchTickets",
		Description: "Search only tickets",
		Method:      "POST",
		Path:        "/api/v1/search",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"query": "email",
			"types": []string{"ticket"},
			"filters": map[string]string{
				"queue_id": "1",
				"state_id": "1",
			},
			"limit":  20,
			"offset": 0,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"hits": ArraySchema{},
			}},
		},
	},
	{
		Name:        "SearchWithHighlighting",
		Description: "Search with result highlighting",
		Method:      "POST",
		Path:        "/api/v1/search",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"query":     "password reset",
			"types":     []string{"ticket", "article"},
			"highlight": true,
			"limit":     5,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"hits": ArraySchema{},
			}},
		},
	},
	{
		Name:        "SearchWithPagination",
		Description: "Search with pagination",
		Method:      "POST",
		Path:        "/api/v1/search",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"query":  "customer",
			"types":  []string{"customer"},
			"offset": 10,
			"limit":  10,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"hits": ArraySchema{},
			}},
		},
	},
	{
		Name:        "SearchSuggestions",
		Description: "Get search suggestions",
		Method:      "GET",
		Path:        "/api/v1/search/suggestions?q=net&type=ticket",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"query":       StringSchema{},
				"type":        StringSchema{},
				"suggestions": ArraySchema{},
			}},
		},
	},
	{
		Name:        "SearchHealth",
		Description: "Check search backend health",
		Method:      "GET",
		Path:        "/api/v1/search/health",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"status":  StringSchema{},
				"backend": StringSchema{},
			}},
		},
	},
	{
		Name:        "Reindex",
		Description: "Trigger search index rebuild",
		Method:      "POST",
		Path:        "/api/v1/search/reindex",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"types": []string{"ticket", "article"},
			"force": false,
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"message": StringSchema{},
				"backend": StringSchema{},
			}},
		},
	},
	{
		Name:        "EmptySearchQuery",
		Description: "Search with empty query should fail",
		Method:      "POST",
		Path:        "/api/v1/search",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"query": "",
			"types": []string{"ticket"},
		},
		Expected: Response{
			Status: http.StatusBadRequest,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"error": StringSchema{},
			}},
		},
	},
}

SearchContracts defines the API contracts for search endpoints

View Source 
var TicketStateContracts = []Contract{
	{
		Name:        "ListTicketStates",
		Description: "List all ticket states",
		Method:      "GET",
		Path:        "/api/v1/ticket-states",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"states": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"id":       NumberSchema{Required: true},
					"name":     StringSchema{Required: true},
					"type_id":  NumberSchema{},
					"valid_id": NumberSchema{},
				}}, Required: true},
				"total": NumberSchema{},
			}},
		},
	},
	{
		Name:        "GetTicketState",
		Description: "Get single ticket state by ID",
		Method:      "GET",
		Path:        "/api/v1/ticket-states/1",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":       NumberSchema{Required: true},
				"name":     StringSchema{Required: true},
				"type_id":  NumberSchema{},
				"valid_id": NumberSchema{},
			}},
		},
	},
	{
		Name:        "CreateTicketState",
		Description: "Create new ticket state",
		Method:      "POST",
		Path:        "/api/v1/ticket-states",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
			"Content-Type":  "application/json",
		},
		Body: map[string]interface{}{
			"name":    "Test State",
			"type_id": 1,
		},
		Expected: Response{
			Status: http.StatusCreated,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"id":       NumberSchema{Required: true},
				"name":     StringSchema{Required: true},
				"type_id":  NumberSchema{},
				"valid_id": NumberSchema{},
			}},
		},
	},
	{
		Name:        "TicketStateStatistics",
		Description: "Get ticket state statistics",
		Method:      "GET",
		Path:        "/api/v1/ticket-states/statistics",
		Headers: map[string]string{
			"Authorization": "Bearer {{token}}",
		},
		Expected: Response{
			Status: http.StatusOK,
			BodySchema: ObjectSchema{Required: true, Properties: map[string]Schema{
				"statistics": ArraySchema{ItemsSchema: ObjectSchema{Properties: map[string]Schema{
					"state_id":     NumberSchema{Required: true},
					"state_name":   StringSchema{Required: true},
					"type_id":      NumberSchema{},
					"ticket_count": NumberSchema{},
				}}, Required: true},
				"total_tickets": NumberSchema{},
			}},
		},
	},
}

TicketStateContracts defines the API contracts for ticket state endpoints

Functions

func RegisterArticleContracts 

func RegisterArticleContracts()

RegisterArticleContracts registers article contracts for testing

func RegisterQueuePriorityContracts 

func RegisterQueuePriorityContracts()

RegisterQueuePriorityContracts registers queue and priority contracts for testing

func RegisterSearchContracts 

func RegisterSearchContracts()

RegisterSearchContracts registers search contracts for testing

func RegisterStateSLAContracts 

func RegisterStateSLAContracts()

RegisterStateSLAContracts registers ticket state and SLA contracts for testing

func ValidateSchema 

func ValidateSchema(actual interface{}, expected interface{}) error

ValidateSchema validates that a response matches expected schema

Types

type ArraySchema 

type ArraySchema struct {
	Required    bool
	MinItems    int
	MaxItems    int
	ItemsSchema Schema
}

ArraySchema validates array fields

func (ArraySchema) Validate 

func (s ArraySchema) Validate(value interface{}) error

type BooleanSchema 

type BooleanSchema struct {
	Required bool
}

BooleanSchema validates boolean fields

func (BooleanSchema) Validate 

func (s BooleanSchema) Validate(value interface{}) error

type Contract 

type Contract struct {
	Name        string
	Description string
	Method      string
	Path        string
	Headers     map[string]string
	Body        interface{}
	Expected    Response
}

Contract defines an API contract to be tested

type ContractTest 

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

ContractTest runs a contract test against a handler

func NewContractTest 

func NewContractTest(t *testing.T, router *gin.Engine) *ContractTest

NewContractTest creates a new contract test runner

func (*ContractTest) AddContract 

func (ct *ContractTest) AddContract(contract Contract)

AddContract adds a contract to test

func (*ContractTest) Run 

func (ct *ContractTest) Run()

Run executes all contract tests

type MockHandlers 

type MockHandlers struct{}

MockHandlers provides mock implementations for contract testing

func (*MockHandlers) HandleAddUserToGroup 

func (m *MockHandlers) HandleAddUserToGroup(c *gin.Context)

func (*MockHandlers) HandleAssignTicket 

func (m *MockHandlers) HandleAssignTicket(c *gin.Context)

func (*MockHandlers) HandleCloseTicket 

func (m *MockHandlers) HandleCloseTicket(c *gin.Context)

Ticket action handlers

func (*MockHandlers) HandleCreateTicket 

func (m *MockHandlers) HandleCreateTicket(c *gin.Context)

func (*MockHandlers) HandleCreateUser 

func (m *MockHandlers) HandleCreateUser(c *gin.Context)

func (*MockHandlers) HandleDeleteTicket 

func (m *MockHandlers) HandleDeleteTicket(c *gin.Context)

func (*MockHandlers) HandleDeleteUser 

func (m *MockHandlers) HandleDeleteUser(c *gin.Context)

func (*MockHandlers) HandleGetTicket 

func (m *MockHandlers) HandleGetTicket(c *gin.Context)

func (*MockHandlers) HandleGetUser 

func (m *MockHandlers) HandleGetUser(c *gin.Context)

func (*MockHandlers) HandleGetUserGroups 

func (m *MockHandlers) HandleGetUserGroups(c *gin.Context)

func (*MockHandlers) HandleListTickets 

func (m *MockHandlers) HandleListTickets(c *gin.Context)

Ticket handlers

func (*MockHandlers) HandleListUsers 

func (m *MockHandlers) HandleListUsers(c *gin.Context)

User handlers

func (*MockHandlers) HandleLogin 

func (m *MockHandlers) HandleLogin(c *gin.Context)

Auth handlers

func (*MockHandlers) HandleLogout 

func (m *MockHandlers) HandleLogout(c *gin.Context)

func (*MockHandlers) HandleRefresh 

func (m *MockHandlers) HandleRefresh(c *gin.Context)

func (*MockHandlers) HandleRemoveUserFromGroup 

func (m *MockHandlers) HandleRemoveUserFromGroup(c *gin.Context)

func (*MockHandlers) HandleReopenTicket 

func (m *MockHandlers) HandleReopenTicket(c *gin.Context)

func (*MockHandlers) HandleUpdateTicket 

func (m *MockHandlers) HandleUpdateTicket(c *gin.Context)

func (*MockHandlers) HandleUpdateUser 

func (m *MockHandlers) HandleUpdateUser(c *gin.Context)

type NumberSchema 

type NumberSchema struct {
	Required bool
	Min      *float64
	Max      *float64
}

NumberSchema validates numeric fields

func (NumberSchema) Validate 

func (s NumberSchema) Validate(value interface{}) error

type ObjectSchema 

type ObjectSchema struct {
	Required   bool
	Properties map[string]Schema
}

ObjectSchema validates object fields

func (ObjectSchema) Validate 

func (s ObjectSchema) Validate(value interface{}) error

type Response 

type Response struct {
	Status      int
	Headers     map[string]string
	BodySchema  interface{} // Expected response structure
	Validations []Validation
}

Response defines expected response characteristics

type Schema 

type Schema interface {
	Validate(interface{}) error
}

Schema interface for custom schema validation

type StringSchema 

type StringSchema struct {
	Required  bool
	MinLength int
	MaxLength int
	Pattern   string
}

StringSchema validates string fields

func (StringSchema) Validate 

func (s StringSchema) Validate(value interface{}) error

type Validation 

type Validation func(body []byte) error

Validation is a custom validation function

func HasFields 

func HasFields(fields ...string) Validation

Helper function to check if response contains expected fields

func IsErrorResponse 

func IsErrorResponse() Validation

Helper function to validate error response format

func IsSuccessResponse 

func IsSuccessResponse() Validation

Helper function to validate success response format

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.