Mirrors/VILLASweb-backend-go
1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/web-backend-go/ synced 2025-03-30 00:00:12 +01:00
Code Issues Releases Wiki Activity

remove basePath and basePath settings

Browse source
This commit is contained in:
Steffen Vogel 2021-02-05 19:26:15 +01:00
parent b24387a22a
commit e4d200e6fd
19 changed files with 792 additions and 625 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
configuration/config.go
View file

@ -50,8 +50,6 @@ func InitConfig() error {
configFile = flag.String("config", "", "Path to YAML configuration file") configFile = flag.String("config", "", "Path to YAML configuration file")
mode = flag.String("mode", "release", "Select debug/release/test mode (default is release)") mode = flag.String("mode", "release", "Select debug/release/test mode (default is release)")
port = flag.String("port", "4000", "Port of the backend (default is 4000)") port = flag.String("port", "4000", "Port of the backend (default is 4000)")
baseHost = flag.String("base-host", "localhost:4000", "The host at which the backend is hosted (default: localhost)")
basePath = flag.String("base-path", "/api/v2", "The path at which the API routes are located (default /api/v2)")
adminUser = flag.String("admin-user", "", "Initial admin username") adminUser = flag.String("admin-user", "", "Initial admin username")
adminPass = flag.String("admin-pass", "", "Initial admin password") adminPass = flag.String("admin-pass", "", "Initial admin password")
adminMail = flag.String("admin-mail", "", "Initial admin mail address") adminMail = flag.String("admin-mail", "", "Initial admin mail address")
@ -85,8 +83,6 @@ func InitConfig() error {
"amqp.pass": *amqpPass, "amqp.pass": *amqpPass,
"mode": *mode, "mode": *mode,
"port": *port, "port": *port,
"base.host": *baseHost,
"base.path": *basePath,
"admin.user": *adminUser, "admin.user": *adminUser,
"admin.pass": *adminPass, "admin.pass": *adminPass,
"admin.mail": *adminMail, "admin.mail": *adminMail,
@ -165,39 +161,29 @@ func InitConfig() error {
return nil return nil
} }
func ConfigureBackend() (string, string, string, string, string, string, string, error) { func ConfigureBackend() (string, string, string, string, string, error) {
err := InitConfig() err := InitConfig()
if err != nil { if err != nil {
log.Printf("Error during initialization of global configuration: %v, aborting.", err.Error()) log.Printf("Error during initialization of global configuration: %v, aborting.", err.Error())
return "", "", "", "", "", "", "", err return "", "", "", "", "", err
} }
mode, err := GlobalConfig.String("mode") mode, err := GlobalConfig.String("mode")
if err != nil { if err != nil {
log.Printf("Error reading mode from global configuration: %v, aborting.", err.Error()) log.Printf("Error reading mode from global configuration: %v, aborting.", err.Error())
return "", "", "", "", "", "", "", err return "", "", "", "", "", err
} }
baseHost, err := GlobalConfig.String("base.host")
if err != nil {
log.Printf("Error reading base.host from global configuration: %v, aborting.", err.Error())
return "", "", "", "", "", "", "", err
}
basePath, err := GlobalConfig.String("base.path")
if err != nil {
log.Printf("Error reading base.path from global configuration: %v, aborting.", err.Error())
return "", "", "", "", "", "", "", err
}
port, err := GlobalConfig.String("port") port, err := GlobalConfig.String("port")
if err != nil { if err != nil {
log.Printf("Error reading port from global configuration: %v, aborting.", err.Error()) log.Printf("Error reading port from global configuration: %v, aborting.", err.Error())
return "", "", "", "", "", "", "", err return "", "", "", "", "", err
} }
AMQPhost, _ := GlobalConfig.String("amqp.host") AMQPhost, _ := GlobalConfig.String("amqp.host")
AMQPuser, _ := GlobalConfig.String("amqp.user") AMQPuser, _ := GlobalConfig.String("amqp.user")
AMQPpass, _ := GlobalConfig.String("amqp.pass") AMQPpass, _ := GlobalConfig.String("amqp.pass")
return mode, baseHost, basePath, port, AMQPhost, AMQPuser, AMQPpass, nil return mode, port, AMQPhost, AMQPuser, AMQPpass, nil
} }

122
doc/api/docs.go
View file

@ -32,6 +32,41 @@ var doc = `{
"basePath": "{{.BasePath}}", "basePath": "{{.BasePath}}",
"paths": { "paths": {
"/authenticate": { "/authenticate": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"authentication"
],
"summary": "Check if user is authenticated and provide details on how the user can authenticate",
"operationId": "authenticated",
"responses": {
"200": {
"description": "JSON web token, success status, message and authenticated user object",
"schema": {
"$ref": "#/definitions/api.ResponseAuthenticate"
}
},
"401": {
"description": "Unauthorized",
"schema": {
"$ref": "#/definitions/api.ResponseError"
}
},
"500": {
"description": "Internal server error.",
"schema": {
"$ref": "#/definitions/api.ResponseError"
}
}
}
}
},
"/authenticate/{mechanism}": {
"post": { "post": {
"consumes": [ "consumes": [
"application/json" "application/json"
@ -53,6 +88,17 @@ var doc = `{
"schema": { "schema": {
"$ref": "#/definitions/user.loginRequest" "$ref": "#/definitions/user.loginRequest"
} }
},
{
"enum": [
"internal",
"external"
],
"type": "string",
"description": "Login mechanism",
"name": "mechanism",
"in": "path",
"required": true
} }
], ],
"responses": { "responses": {
@ -77,6 +123,26 @@ var doc = `{
} }
} }
}, },
"/config": {
"get": {
"produces": [
"application/json"
],
"tags": [
"config"
],
"summary": "Get config VILLASweb to be used by frontend",
"operationId": "config",
"responses": {
"200": {
"description": "The configuration",
"schema": {
"$ref": "#/definitions/config.Config"
}
}
}
}
},
"/configs": { "/configs": {
"get": { "get": {
"security": [ "security": [
@ -3346,6 +3412,62 @@ var doc = `{
} }
} }
}, },
"config.Config": {
"type": "object",
"properties": {
"authentication": {
"$ref": "#/definitions/config.ConfigAuthentication"
},
"contact": {
"$ref": "#/definitions/config.ConfigContact"
},
"mode": {
"type": "string"
},
"sub_title": {
"type": "string"
},
"title": {
"type": "string"
}
}
},
"config.ConfigAuthentication": {
"type": "object",
"properties": {
"external": {
"$ref": "#/definitions/config.ConfigAuthenticationExternal"
},
"logout_url": {
"type": "string"
}
}
},
"config.ConfigAuthenticationExternal": {
"type": "object",
"properties": {
"authorize_url": {
"type": "string"
},
"enabled": {
"type": "boolean"
},
"provider_name": {
"type": "string"
}
}
},
"config.ConfigContact": {
"type": "object",
"properties": {
"mail": {
"type": "string"
},
"name": {
"type": "string"
}
}
},
"dashboard.addDashboardRequest": { "dashboard.addDashboardRequest": {
"type": "object", "type": "object",
"properties": { "properties": {

122
doc/api/swagger.json
View file

@ -16,6 +16,41 @@
"basePath": "/api/v2", "basePath": "/api/v2",
"paths": { "paths": {
"/authenticate": { "/authenticate": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"tags": [
"authentication"
],
"summary": "Check if user is authenticated and provide details on how the user can authenticate",
"operationId": "authenticated",
"responses": {
"200": {
"description": "JSON web token, success status, message and authenticated user object",
"schema": {
"$ref": "#/definitions/api.ResponseAuthenticate"
}
},
"401": {
"description": "Unauthorized",
"schema": {
"$ref": "#/definitions/api.ResponseError"
}
},
"500": {
"description": "Internal server error.",
"schema": {
"$ref": "#/definitions/api.ResponseError"
}
}
}
}
},
"/authenticate/{mechanism}": {
"post": { "post": {
"consumes": [ "consumes": [
"application/json" "application/json"
@ -37,6 +72,17 @@
"schema": { "schema": {
"$ref": "#/definitions/user.loginRequest" "$ref": "#/definitions/user.loginRequest"
} }
},
{
"enum": [
"internal",
"external"
],
"type": "string",
"description": "Login mechanism",
"name": "mechanism",
"in": "path",
"required": true
} }
], ],
"responses": { "responses": {
@ -61,6 +107,26 @@
} }
} }
}, },
"/config": {
"get": {
"produces": [
"application/json"
],
"tags": [
"config"
],
"summary": "Get config VILLASweb to be used by frontend",
"operationId": "config",
"responses": {
"200": {
"description": "The configuration",
"schema": {
"$ref": "#/definitions/config.Config"
}
}
}
}
},
"/configs": { "/configs": {
"get": { "get": {
"security": [ "security": [
@ -3330,6 +3396,62 @@
} }
} }
}, },
"config.Config": {
"type": "object",
"properties": {
"authentication": {
"$ref": "#/definitions/config.ConfigAuthentication"
},
"contact": {
"$ref": "#/definitions/config.ConfigContact"
},
"mode": {
"type": "string"
},
"sub_title": {
"type": "string"
},
"title": {
"type": "string"
}
}
},
"config.ConfigAuthentication": {
"type": "object",
"properties": {
"external": {
"$ref": "#/definitions/config.ConfigAuthenticationExternal"
},
"logout_url": {
"type": "string"
}
}
},
"config.ConfigAuthenticationExternal": {
"type": "object",
"properties": {
"authorize_url": {
"type": "string"
},
"enabled": {
"type": "boolean"
},
"provider_name": {
"type": "string"
}
}
},
"config.ConfigContact": {
"type": "object",
"properties": {
"mail": {
"type": "string"
},
"name": {
"type": "string"
}
}
},
"dashboard.addDashboardRequest": { "dashboard.addDashboardRequest": {
"type": "object", "type": "object",
"properties": { "properties": {

100
doc/api/swagger.yaml
View file

@ -83,6 +83,42 @@ definitions:
StartParameters: StartParameters:
$ref: '#/definitions/postgres.Jsonb' $ref: '#/definitions/postgres.Jsonb'
type: object type: object
config.Config:
properties:
authentication:
$ref: '#/definitions/config.ConfigAuthentication'
contact:
$ref: '#/definitions/config.ConfigContact'
mode:
type: string
sub_title:
type: string
title:
type: string
type: object
config.ConfigAuthentication:
properties:
external:
$ref: '#/definitions/config.ConfigAuthenticationExternal'
logout_url:
type: string
type: object
config.ConfigAuthenticationExternal:
properties:
authorize_url:
type: string
enabled:
type: boolean
provider_name:
type: string
type: object
config.ConfigContact:
properties:
mail:
type: string
name:
type: string
type: object
dashboard.addDashboardRequest: dashboard.addDashboardRequest:
properties: properties:
dashboard: dashboard:
@ -446,6 +482,31 @@ info:
version: "2.0" version: "2.0"
paths: paths:
/authenticate: /authenticate:
get:
consumes:
- application/json
operationId: authenticated
produces:
- application/json
responses:
"200":
description: JSON web token, success status, message and authenticated user
object
schema:
$ref: '#/definitions/api.ResponseAuthenticate'
"401":
description: Unauthorized
schema:
$ref: '#/definitions/api.ResponseError'
"500":
description: Internal server error.
schema:
$ref: '#/definitions/api.ResponseError'
summary: Check if user is authenticated and provide details on how the user
can authenticate
tags:
- authentication
/authenticate/{mechanism}:
post: post:
consumes: consumes:
- application/json - application/json
@ -457,11 +518,20 @@ paths:
required: true required: true
schema: schema:
$ref: '#/definitions/user.loginRequest' $ref: '#/definitions/user.loginRequest'
- description: Login mechanism
enum:
- internal
- external
in: path
name: mechanism
required: true
type: string
produces: produces:
- application/json - application/json
responses: responses:
"200": "200":
description: JSON web token, success status, message and authenticated user object description: JSON web token, success status, message and authenticated user
object
schema: schema:
$ref: '#/definitions/api.ResponseAuthenticate' $ref: '#/definitions/api.ResponseAuthenticate'
"401": "401":
@ -475,6 +545,19 @@ paths:
summary: Authentication for user summary: Authentication for user
tags: tags:
- authentication - authentication
/config:
get:
operationId: config
produces:
- application/json
responses:
"200":
description: The configuration
schema:
$ref: '#/definitions/config.Config'
summary: Get config VILLASweb to be used by frontend
tags:
- config
/configs: /configs:
get: get:
operationId: getConfigs operationId: getConfigs
@ -513,7 +596,8 @@ paths:
- application/json - application/json
operationId: addConfig operationId: addConfig
parameters: parameters:
- description: component configuration to be added incl. IDs of scenario and IC - description: component configuration to be added incl. IDs of scenario and
IC
in: body in: body
name: inputConfig name: inputConfig
required: true required: true
@ -1078,7 +1162,8 @@ paths:
- application/json - application/json
responses: responses:
"204": "204":
description: Backend is healthy, database and AMQP broker connections are alive description: Backend is healthy, database and AMQP broker connections are
alive
schema: schema:
type: string type: string
"500": "500":
@ -1310,7 +1395,8 @@ paths:
$ref: '#/definitions/api.ResponseError' $ref: '#/definitions/api.ResponseError'
security: security:
- Bearer: [] - Bearer: []
summary: Send an action to IC (only available if backend server is started with -amqp parameter) summary: Send an action to IC (only available if backend server is started with
-amqp parameter)
tags: tags:
- infrastructure-components - infrastructure-components
/ic/{ICID}/configs: /ic/{ICID}/configs:
@ -1986,7 +2072,8 @@ paths:
- application/json - application/json
operationId: AddSignal operationId: AddSignal
parameters: parameters:
- description: A signal to be added to the component configuration incl. direction and config ID to which signal shall be added - description: A signal to be added to the component configuration incl. direction
and config ID to which signal shall be added
in: body in: body
name: inputSignal name: inputSignal
required: true required: true
@ -2271,7 +2358,8 @@ paths:
- application/json - application/json
operationId: UpdateUser operationId: UpdateUser
parameters: parameters:
- description: User to be updated (anything except for ID can be changed, role can only be change by admin) - description: User to be updated (anything except for ID can be changed, role
can only be change by admin)
in: body in: body
name: inputUser name: inputUser
required: true required: true

5
helper/test_utilities.go
View file

@ -266,8 +266,7 @@ func CompareResponse(resp *bytes.Buffer, expected interface{}) error {
} }
// Authenticate a user for testing purposes // Authenticate a user for testing purposes
func AuthenticateForTest(router *gin.Engine, url string, func AuthenticateForTest(router *gin.Engine, credentials interface{}) (string, error) {
method string, credentials interface{}) (string, error) {
w := httptest.NewRecorder() w := httptest.NewRecorder()
@ -277,7 +276,7 @@ func AuthenticateForTest(router *gin.Engine, url string,
return "", fmt.Errorf("Failed to marshal credentials: %v", err) return "", fmt.Errorf("Failed to marshal credentials: %v", err)
} }
req, err := http.NewRequest(method, url, bytes.NewBuffer(body)) req, err := http.NewRequest("POST", "/api/v2/authenticate/internal", bytes.NewBuffer(body))
if err != nil { if err != nil {
return "", fmt.Errorf("Failed to create new request: %v", err) return "", fmt.Errorf("Failed to create new request: %v", err)
} }

59
routes/component-configuration/config_test.go
View file

@ -39,8 +39,8 @@ import (
) )
var router *gin.Engine var router *gin.Engine
var base_api_configs = "/api/configs" var base_api_configs = "/api/v2/configs"
var base_api_auth = "/api/authenticate" var base_api_auth = "/api/v2/authenticate"
type ConfigRequest struct { type ConfigRequest struct {
Name string `json:"name,omitempty"` Name string `json:"name,omitempty"`
@ -83,8 +83,7 @@ func newFalse() *bool {
func addScenarioAndIC() (scenarioID uint, ICID uint) { func addScenarioAndIC() (scenarioID uint, ICID uint) {
// authenticate as admin // authenticate as admin
token, _ := helper.AuthenticateForTest(router, token, _ := helper.AuthenticateForTest(router, helper.AdminCredentials)
base_api_auth, "POST", helper.AdminCredentials)
// POST $newICA // POST $newICA
newICA := ICRequest{ newICA := ICRequest{
@ -101,7 +100,7 @@ func addScenarioAndIC() (scenarioID uint, ICID uint) {
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newICA}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newICA})
if code != 200 || err != nil { if code != 200 || err != nil {
fmt.Println("Adding IC returned code", code, err, resp) fmt.Println("Adding IC returned code", code, err, resp)
} }
@ -111,14 +110,13 @@ func addScenarioAndIC() (scenarioID uint, ICID uint) {
// POST a second IC to change to that IC during testing // POST a second IC to change to that IC during testing
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newICA}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newICA})
if code != 200 || err != nil { if code != 200 || err != nil {
fmt.Println("Adding IC returned code", code, err, resp) fmt.Println("Adding IC returned code", code, err, resp)
} }
// authenticate as normal user // authenticate as normal user
token, _ = helper.AuthenticateForTest(router, token, _ = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
// POST $newScenario // POST $newScenario
newScenario := ScenarioRequest{ newScenario := ScenarioRequest{
@ -127,7 +125,7 @@ func addScenarioAndIC() (scenarioID uint, ICID uint) {
StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
if code != 200 || err != nil { if code != 200 || err != nil {
fmt.Println("Adding Scenario returned code", code, err, resp) fmt.Println("Adding Scenario returned code", code, err, resp)
} }
@ -137,7 +135,7 @@ func addScenarioAndIC() (scenarioID uint, ICID uint) {
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID), uint(newICID) return uint(newScenarioID), uint(newICID)
} }
@ -155,7 +153,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -183,8 +181,7 @@ func TestAddConfig(t *testing.T) {
newConfig1.ScenarioID = scenarioID newConfig1.ScenarioID = scenarioID
newConfig1.ICID = ICID newConfig1.ICID = ICID
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST with no access // try to POST with no access
@ -195,8 +192,7 @@ func TestAddConfig(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST non JSON body // try to POST non JSON body
@ -206,8 +202,7 @@ func TestAddConfig(t *testing.T) {
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newConfig // test POST newConfig
@ -246,8 +241,7 @@ func TestAddConfig(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Try to GET the newConfig with no access // Try to GET the newConfig with no access
@ -271,8 +265,7 @@ func TestUpdateConfig(t *testing.T) {
scenarioID, ICID := addScenarioAndIC() scenarioID, ICID := addScenarioAndIC()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newConfig // test POST newConfig
@ -293,8 +286,7 @@ func TestUpdateConfig(t *testing.T) {
} }
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT with no access // try to PUT with no access
@ -305,8 +297,7 @@ func TestUpdateConfig(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as guest user who has access to component config // authenticate as guest user who has access to component config
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
base_api_auth, "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT as guest // try to PUT as guest
@ -317,8 +308,7 @@ func TestUpdateConfig(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT a non JSON body // try to PUT a non JSON body
@ -380,8 +370,7 @@ func TestDeleteConfig(t *testing.T) {
newConfig1.ICID = ICID newConfig1.ICID = ICID
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newConfig // test POST newConfig
@ -395,8 +384,7 @@ func TestDeleteConfig(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE with no access // try to DELETE with no access
@ -407,8 +395,7 @@ func TestDeleteConfig(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the component config returned for scenario // Count the number of all the component config returned for scenario
@ -447,8 +434,7 @@ func TestGetAllConfigsOfScenario(t *testing.T) {
newConfig1.ICID = ICID newConfig1.ICID = ICID
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newConfig // test POST newConfig
@ -465,8 +451,7 @@ func TestGetAllConfigsOfScenario(t *testing.T) {
assert.Equal(t, 1, NumberOfConfigs) assert.Equal(t, 1, NumberOfConfigs)
// authenticate as normal userB who has no access to scenario // authenticate as normal userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get configs without access // try to get configs without access

4
routes/config/config_endpoint.go
View file

@ -51,8 +51,6 @@ type Config struct {
Title string `json:"title"` Title string `json:"title"`
SubTitle string `json:"sub_title"` SubTitle string `json:"sub_title"`
Mode string `json:"mode"` Mode string `json:"mode"`
BaseHost string `json:"base_host"`
BasePath string `json:"base_path"`
Contact ConfigContact `json:"contact"` Contact ConfigContact `json:"contact"`
Authentication ConfigAuthentication `json:"authentication"` Authentication ConfigAuthentication `json:"authentication"`
} }
@ -71,8 +69,6 @@ func getConfig(c *gin.Context) {
resp := &Config{} resp := &Config{}
resp.Mode, _ = cfg.String("mode") resp.Mode, _ = cfg.String("mode")
resp.BaseHost, _ = cfg.String("base.host")
resp.BasePath, _ = cfg.String("base.path")
resp.Authentication.LogoutURL, _ = cfg.String("auth.logout-url") resp.Authentication.LogoutURL, _ = cfg.String("auth.logout-url")
resp.Authentication.External.Enabled, _ = cfg.Bool("auth.external") resp.Authentication.External.Enabled, _ = cfg.Bool("auth.external")
resp.Authentication.External.AuthorizeURL, _ = cfg.String("auth.external.authorize-url") resp.Authentication.External.AuthorizeURL, _ = cfg.String("auth.external.authorize-url")

86
routes/dashboard/dashboard_test.go
View file

@ -67,7 +67,7 @@ func addScenario(token string) (scenarioID uint) {
StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
_, resp, err := helper.TestEndpoint(router, token, _, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
if err != nil { if err != nil {
log.Panic("The following error happend on POSTing a scenario: ", err.Error()) log.Panic("The following error happend on POSTing a scenario: ", err.Error())
} }
@ -77,7 +77,7 @@ func addScenario(token string) (scenarioID uint) {
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID) return uint(newScenarioID)
} }
@ -94,7 +94,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -112,8 +112,7 @@ func TestAddDashboard(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
scenarioID := addScenario(token) scenarioID := addScenario(token)
@ -121,7 +120,7 @@ func TestAddDashboard(t *testing.T) {
// test POST dashboards/ $newDashboad // test POST dashboards/ $newDashboad
newDashboard.ScenarioID = scenarioID newDashboard.ScenarioID = scenarioID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -135,7 +134,7 @@ func TestAddDashboard(t *testing.T) {
// Get the newDashboard // Get the newDashboard
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "GET", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -150,13 +149,13 @@ func TestAddDashboard(t *testing.T) {
} }
// this should NOT work and return a unprocessable entity 442 status code // this should NOT work and return a unprocessable entity 442 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": malformedNewDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": malformedNewDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// this should NOT work and return a bad request 400 status code // this should NOT work and return a bad request 400 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", "This is a test using plain text as body") "/api/v2/dashboards", "POST", "This is a test using plain text as body")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -164,18 +163,17 @@ func TestAddDashboard(t *testing.T) {
// should return not found error // should return not found error
newDashboard.ScenarioID = scenarioID + 1 newDashboard.ScenarioID = scenarioID + 1
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// try to get dashboard as a user that is not in the scenario (userB) // try to get dashboard as a user that is not in the scenario (userB)
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// this should fail with unprocessable entity // this should fail with unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "GET", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -183,7 +181,7 @@ func TestAddDashboard(t *testing.T) {
// this should give an unprocessable entity error // this should give an unprocessable entity error
newDashboard.ScenarioID = scenarioID newDashboard.ScenarioID = scenarioID
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
} }
@ -194,8 +192,7 @@ func TestUpdateDashboard(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
scenarioID := addScenario(token) scenarioID := addScenario(token)
@ -203,7 +200,7 @@ func TestUpdateDashboard(t *testing.T) {
// test POST dashboards/ $newDashboard // test POST dashboards/ $newDashboard
newDashboard.ScenarioID = scenarioID newDashboard.ScenarioID = scenarioID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -217,24 +214,22 @@ func TestUpdateDashboard(t *testing.T) {
} }
// authenticate as guest user // authenticate as guest user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to update a dashboard as guest // try to update a dashboard as guest
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "PUT", helper.KeyModels{"dashboard": updatedDashboard}) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "PUT", helper.KeyModels{"dashboard": updatedDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "PUT", helper.KeyModels{"dashboard": updatedDashboard}) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "PUT", helper.KeyModels{"dashboard": updatedDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -244,7 +239,7 @@ func TestUpdateDashboard(t *testing.T) {
// Get the updatedDashboard // Get the updatedDashboard
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "GET", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -254,13 +249,13 @@ func TestUpdateDashboard(t *testing.T) {
// try to update a dashboard that does not exist (should return not found 404 status code) // try to update a dashboard that does not exist (should return not found 404 status code)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID+1), "PUT", helper.KeyModels{"dashboard": updatedDashboard}) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID+1), "PUT", helper.KeyModels{"dashboard": updatedDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// try to update with a malformed body, should return a bad request error // try to update with a malformed body, should return a bad request error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "PUT", "This is the body of a malformed update request.") fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "PUT", "This is the body of a malformed update request.")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
} }
@ -271,8 +266,7 @@ func TestDeleteDashboard(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
scenarioID := addScenario(token) scenarioID := addScenario(token)
@ -280,7 +274,7 @@ func TestDeleteDashboard(t *testing.T) {
// test POST dashboards/ $newDashboard // test POST dashboards/ $newDashboard
newDashboard.ScenarioID = scenarioID newDashboard.ScenarioID = scenarioID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -289,35 +283,33 @@ func TestDeleteDashboard(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// try to delete a dashboard from a scenario to which the user has no access // try to delete a dashboard from a scenario to which the user has no access
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// this should fail with unprocessable entity // this should fail with unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "DELETE", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to delete a dashboard that does not exist; should return a not found error // try to delete a dashboard that does not exist; should return a not found error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID+1), "DELETE", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID+1), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// Count the number of all the dashboards returned for scenario // Count the number of all the dashboards returned for scenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added newDashboard // Delete the added newDashboard
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards/%v", newDashboardID), "DELETE", nil) fmt.Sprintf("/api/v2/dashboards/%v", newDashboardID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -327,7 +319,7 @@ func TestDeleteDashboard(t *testing.T) {
// Again count the number of all the dashboards returned for scenario // Again count the number of all the dashboards returned for scenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber-1) assert.Equal(t, finalNumber, initialNumber-1)
@ -340,21 +332,20 @@ func TestGetAllDashboardsOfScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
scenarioID := addScenario(token) scenarioID := addScenario(token)
// Count the number of all the dashboards returned for scenario // Count the number of all the dashboards returned for scenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// test POST dashboards/ $newDashboard // test POST dashboards/ $newDashboard
newDashboard.ScenarioID = scenarioID newDashboard.ScenarioID = scenarioID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -365,31 +356,30 @@ func TestGetAllDashboardsOfScenario(t *testing.T) {
ScenarioID: scenarioID, ScenarioID: scenarioID,
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboardB}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboardB})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Count again the number of all the dashboards returned for scenario // Count again the number of all the dashboards returned for scenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber+2, finalNumber) assert.Equal(t, initialNumber+2, finalNumber)
// try to get all dashboards of a scenario that does not exist (should fail with not found) // try to get all dashboards of a scenario that does not exist (should fail with not found)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID+1), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID+1), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// try to get all dashboards as a user that does not belong to scenario // try to get all dashboards as a user that does not belong to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// this should fail with unprocessable entity // this should fail with unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/dashboards?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/dashboards?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)

108
routes/file/file_test.go
View file

@ -54,12 +54,10 @@ type ScenarioRequest struct {
func addScenario() (scenarioID uint) { func addScenario() (scenarioID uint) {
// authenticate as admin // authenticate as admin
token, _ := helper.AuthenticateForTest(router, token, _ := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
// authenticate as normal user // authenticate as normal user
token, _ = helper.AuthenticateForTest(router, token, _ = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
// POST $newScenario // POST $newScenario
newScenario := ScenarioRequest{ newScenario := ScenarioRequest{
@ -68,14 +66,14 @@ func addScenario() (scenarioID uint) {
StartParameters: postgres.Jsonb{RawMessage: json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{RawMessage: json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
_, resp, _ := helper.TestEndpoint(router, token, _, resp, _ := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
// Read newScenario's ID from the response // Read newScenario's ID from the response
newScenarioID, _ := helper.GetResponseID(resp) newScenarioID, _ := helper.GetResponseID(resp)
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID) return uint(newScenarioID)
} }
@ -92,7 +90,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -114,8 +112,7 @@ func TestAddFile(t *testing.T) {
scenarioID := addScenario() scenarioID := addScenario()
// authenticate as userB who has no access to the elements in the DB // authenticate as userB who has no access to the elements in the DB
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
emptyBuf := &bytes.Buffer{} emptyBuf := &bytes.Buffer{}
@ -123,26 +120,25 @@ func TestAddFile(t *testing.T) {
// try to POST to a scenario to which UserB has no access // try to POST to a scenario to which UserB has no access
// should return a 422 unprocessable entity error // should return a 422 unprocessable entity error
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "POST", emptyBuf) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "POST", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal userA // authenticate as normal userA
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST without a scenario ID // try to POST without a scenario ID
// should return a bad request error // should return a bad request error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files"), "POST", emptyBuf) fmt.Sprintf("/api/v2/files"), "POST", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// try to POST an invalid file // try to POST an invalid file
// should return a bad request // should return a bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "POST", emptyBuf) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "POST", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -171,7 +167,7 @@ func TestAddFile(t *testing.T) {
// Create the request // Create the request
w := httptest.NewRecorder() w := httptest.NewRecorder()
req, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf) req, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req.Header.Set("Content-Type", contentType) req.Header.Set("Content-Type", contentType)
@ -185,20 +181,19 @@ func TestAddFile(t *testing.T) {
// Get the new file // Get the new file
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "GET", nil) fmt.Sprintf("/api/v2/files/%v", newFileID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
assert.Equalf(t, string(c1), resp.String(), "Response body: \n%v\n", resp) assert.Equalf(t, string(c1), resp.String(), "Response body: \n%v\n", resp)
// authenticate as userB who has no access to the elements in the DB // authenticate as userB who has no access to the elements in the DB
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get a file to which user has no access // try to get a file to which user has no access
// should return unprocessable entity // should return unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "GET", nil) fmt.Sprintf("/api/v2/files/%v", newFileID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -215,8 +210,7 @@ func TestUpdateFile(t *testing.T) {
scenarioID := addScenario() scenarioID := addScenario()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// create a testfile.txt in local folder // create a testfile.txt in local folder
@ -243,7 +237,7 @@ func TestUpdateFile(t *testing.T) {
// Create the POST request // Create the POST request
w := httptest.NewRecorder() w := httptest.NewRecorder()
req, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf) req, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req.Header.Set("Content-Type", contentType) req.Header.Set("Content-Type", contentType)
@ -256,8 +250,7 @@ func TestUpdateFile(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as userB who has no access to the elements in the DB // authenticate as userB who has no access to the elements in the DB
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
emptyBuf := &bytes.Buffer{} emptyBuf := &bytes.Buffer{}
@ -265,32 +258,30 @@ func TestUpdateFile(t *testing.T) {
// try to PUT to a file to which UserB has no access // try to PUT to a file to which UserB has no access
// should return a 422 unprocessable entity error // should return a 422 unprocessable entity error
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "PUT", emptyBuf) fmt.Sprintf("/api/v2/files/%v", newFileID), "PUT", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as guest user C // authenticate as guest user C
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT as guest // try to PUT as guest
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "PUT", emptyBuf) fmt.Sprintf("/api/v2/files/%v", newFileID), "PUT", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// Prepare update // Prepare update
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT with empty body // try to PUT with empty body
// should return bad request // should return bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "PUT", emptyBuf) fmt.Sprintf("/api/v2/files/%v", newFileID), "PUT", emptyBuf)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -318,7 +309,7 @@ func TestUpdateFile(t *testing.T) {
// Create the PUT request // Create the PUT request
w_updated := httptest.NewRecorder() w_updated := httptest.NewRecorder()
req, err = http.NewRequest("PUT", fmt.Sprintf("/api/files/%v", newFileID), bodyBufUpdated) req, err = http.NewRequest("PUT", fmt.Sprintf("/api/v2/files/%v", newFileID), bodyBufUpdated)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req.Header.Set("Content-Type", contentType) req.Header.Set("Content-Type", contentType)
@ -332,7 +323,7 @@ func TestUpdateFile(t *testing.T) {
// Get the updated file // Get the updated file
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileIDUpdated), "GET", nil) fmt.Sprintf("/api/v2/files/%v", newFileIDUpdated), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
assert.Equalf(t, string(c2), resp.String(), "Response body: \n%v\n", resp) assert.Equalf(t, string(c2), resp.String(), "Response body: \n%v\n", resp)
@ -348,8 +339,7 @@ func TestDeleteFile(t *testing.T) {
scenarioID := addScenario() scenarioID := addScenario()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// create a testfile.txt in local folder // create a testfile.txt in local folder
@ -375,7 +365,7 @@ func TestDeleteFile(t *testing.T) {
// Create the request // Create the request
w := httptest.NewRecorder() w := httptest.NewRecorder()
req, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf) req, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req.Header.Set("Content-Type", contentType) req.Header.Set("Content-Type", contentType)
req.Header.Add("Authorization", "Bearer "+token) req.Header.Add("Authorization", "Bearer "+token)
@ -398,7 +388,7 @@ func TestDeleteFile(t *testing.T) {
// Create the request // Create the request
w2 := httptest.NewRecorder() w2 := httptest.NewRecorder()
req2, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf2) req2, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf2)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req2.Header.Set("Content-Type", contentType2) req2.Header.Set("Content-Type", contentType2)
req2.Header.Add("Authorization", "Bearer "+token) req2.Header.Add("Authorization", "Bearer "+token)
@ -409,66 +399,62 @@ func TestDeleteFile(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as userB who has no access to the elements in the DB // authenticate as userB who has no access to the elements in the DB
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE file from scenario to which userB has no access // try to DELETE file from scenario to which userB has no access
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "DELETE", nil) fmt.Sprintf("/api/v2/files/%v", newFileID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all files returned for scenario // Count the number of all files returned for scenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE non-existing fileID // try to DELETE non-existing fileID
// should return not found // should return not found
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/5"), "DELETE", nil) fmt.Sprintf("/api/v2/files/5"), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// authenticate as guest user C // authenticate as guest user C
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE file of scenario as guest // try to DELETE file of scenario as guest
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "DELETE", nil) fmt.Sprintf("/api/v2/files/%v", newFileID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added file 1 // Delete the added file 1
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID), "DELETE", nil) fmt.Sprintf("/api/v2/files/%v", newFileID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Delete the added file 2 // Delete the added file 2
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files/%v", newFileID2), "DELETE", nil) fmt.Sprintf("/api/v2/files/%v", newFileID2), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Again count the number of all the files returned for scenario // Again count the number of all the files returned for scenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber-2, finalNumber) assert.Equal(t, initialNumber-2, finalNumber)
@ -485,31 +471,29 @@ func TestGetAllFilesOfScenario(t *testing.T) {
scenarioID := addScenario() scenarioID := addScenario()
// authenticate as userB who has no access to the elements in the DB // authenticate as userB who has no access to the elements in the DB
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get all files for scenario to which userB has not access // try to get all files for scenario to which userB has not access
// should return unprocessable entity error // should return unprocessable entity error
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal userA // authenticate as normal userA
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
//try to get all files with missing scenario ID; should return a bad request error //try to get all files with missing scenario ID; should return a bad request error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/files"), "GET", nil) fmt.Sprintf("/api/v2/files"), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// Count the number of all files returned for scenario // Count the number of all files returned for scenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// create a testfile.txt in local folder // create a testfile.txt in local folder
@ -535,7 +519,7 @@ func TestGetAllFilesOfScenario(t *testing.T) {
// Create the request // Create the request
w := httptest.NewRecorder() w := httptest.NewRecorder()
req, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf1) req, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf1)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req.Header.Set("Content-Type", contentType1) req.Header.Set("Content-Type", contentType1)
req.Header.Add("Authorization", "Bearer "+token) req.Header.Add("Authorization", "Bearer "+token)
@ -561,7 +545,7 @@ func TestGetAllFilesOfScenario(t *testing.T) {
bodyWriter2.Close() bodyWriter2.Close()
w2 := httptest.NewRecorder() w2 := httptest.NewRecorder()
req2, err := http.NewRequest("POST", fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), bodyBuf2) req2, err := http.NewRequest("POST", fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), bodyBuf2)
assert.NoError(t, err, "create request") assert.NoError(t, err, "create request")
req2.Header.Set("Content-Type", contentType2) req2.Header.Set("Content-Type", contentType2)
req2.Header.Add("Authorization", "Bearer "+token) req2.Header.Add("Authorization", "Bearer "+token)
@ -570,7 +554,7 @@ func TestGetAllFilesOfScenario(t *testing.T) {
// Again count the number of all the files returned for scenario // Again count the number of all the files returned for scenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/files?scenarioID=%v", scenarioID), "GET", nil) fmt.Sprintf("/api/v2/files?scenarioID=%v", scenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber+2, finalNumber) assert.Equal(t, initialNumber+2, finalNumber)
} }

136
routes/infrastructure-component/ic_test.go
View file

@ -24,12 +24,13 @@ package infrastructure_component
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"github.com/streadway/amqp"
"log" "log"
"os" "os"
"testing" "testing"
"time" "time"
"github.com/streadway/amqp"
"git.rwth-aachen.de/acs/public/villas/web-backend-go/helper" "git.rwth-aachen.de/acs/public/villas/web-backend-go/helper"
component_configuration "git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/component-configuration" component_configuration "git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/component-configuration"
"git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/scenario" "git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/scenario"
@ -131,7 +132,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api = router.Group("/api") api = router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -172,14 +173,13 @@ func TestAddICAsAdmin(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST with non JSON body // try to POST with non JSON body
// should result in bad request // should result in bad request
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", "This is no JSON") "/api/v2/ic", "POST", "This is no JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -189,13 +189,13 @@ func TestAddICAsAdmin(t *testing.T) {
UUID: newIC2.UUID, UUID: newIC2.UUID,
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newMalformedIC}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newMalformedIC})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// test POST ic/ $newIC // test POST ic/ $newIC
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -209,7 +209,7 @@ func TestAddICAsAdmin(t *testing.T) {
// Get the newIC // Get the newIC
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "GET", nil) fmt.Sprintf("/api/v2/ic/%v", newICID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -221,13 +221,13 @@ func TestAddICAsAdmin(t *testing.T) {
// Try to GET a IC that does not exist // Try to GET a IC that does not exist
// should result in not found // should result in not found
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID+1), "GET", nil) fmt.Sprintf("/api/v2/ic/%v", newICID+1), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// test creation of external IC (should lead to emission of AMQP message to VILLAS) // test creation of external IC (should lead to emission of AMQP message to VILLAS)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC2}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC2})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -245,8 +245,7 @@ func TestAddICAsUser(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as user // authenticate as user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newIC // test POST ic/ $newIC
@ -254,7 +253,7 @@ func TestAddICAsUser(t *testing.T) {
// Normal users are not allowed to add ICs // Normal users are not allowed to add ICs
newIC1.ManagedExternally = newFalse() newIC1.ManagedExternally = newFalse()
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
} }
@ -265,13 +264,12 @@ func TestUpdateICAsAdmin(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newIC // test POST ic/ $newIC
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -286,14 +284,14 @@ func TestUpdateICAsAdmin(t *testing.T) {
// try to PUT with non JSON body // try to PUT with non JSON body
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "PUT", "This is no JSON") fmt.Sprintf("/api/v2/ic/%v", newICID), "PUT", "This is no JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// Test PUT IC // Test PUT IC
newIC1.WebsocketURL = "ThisIsMyNewURL" newIC1.WebsocketURL = "ThisIsMyNewURL"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "PUT", helper.KeyModels{"ic": newIC1}) fmt.Sprintf("/api/v2/ic/%v", newICID), "PUT", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -303,7 +301,7 @@ func TestUpdateICAsAdmin(t *testing.T) {
// Get the updated newIC // Get the updated newIC
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "GET", nil) fmt.Sprintf("/api/v2/ic/%v", newICID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -355,7 +353,7 @@ func TestUpdateICAsAdmin(t *testing.T) {
// Should result in forbidden return code 403 // Should result in forbidden return code 403
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", 2), "PUT", helper.KeyModels{"ic": updatedIC}) fmt.Sprintf("/api/v2/ic/%v", 2), "PUT", helper.KeyModels{"ic": updatedIC})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
} }
@ -366,13 +364,12 @@ func TestUpdateICAsUser(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newIC // test POST ic/ $newIC
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -381,15 +378,14 @@ func TestUpdateICAsUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as user // authenticate as user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Test PUT IC // Test PUT IC
// This should fail with unprocessable entity status code 422 // This should fail with unprocessable entity status code 422
newIC1.WebsocketURL = "ThisIsMyNewURL2" newIC1.WebsocketURL = "ThisIsMyNewURL2"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "PUT", helper.KeyModels{"ic": newIC1}) fmt.Sprintf("/api/v2/ic/%v", newICID), "PUT", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -401,13 +397,12 @@ func TestDeleteICAsAdmin(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newIC // test POST ic/ $newIC
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -417,12 +412,12 @@ func TestDeleteICAsAdmin(t *testing.T) {
// Count the number of all the ICs returned for admin // Count the number of all the ICs returned for admin
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added newIC // Delete the added newIC
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "DELETE", nil) fmt.Sprintf("/api/v2/ic/%v", newICID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -432,7 +427,7 @@ func TestDeleteICAsAdmin(t *testing.T) {
// Again count the number of all the ICs returned // Again count the number of all the ICs returned
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber-1) assert.Equal(t, finalNumber, initialNumber-1)
@ -476,7 +471,7 @@ func TestDeleteICAsAdmin(t *testing.T) {
// Delete the added external IC (triggers an AMQP message, but should not remove the IC from the DB) // Delete the added external IC (triggers an AMQP message, but should not remove the IC from the DB)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", 2), "DELETE", nil) fmt.Sprintf("/api/v2/ic/%v", 2), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -485,7 +480,7 @@ func TestDeleteICAsAdmin(t *testing.T) {
// Again count the number of all the ICs returned // Again count the number of all the ICs returned
finalNumberAfterExtneralDelete, err := helper.LengthOfResponse(router, token, finalNumberAfterExtneralDelete, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber+1, finalNumberAfterExtneralDelete) assert.Equal(t, finalNumber+1, finalNumberAfterExtneralDelete)
@ -498,13 +493,12 @@ func TestDeleteICAsUser(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newIC // test POST ic/ $newIC
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -513,15 +507,14 @@ func TestDeleteICAsUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as user // authenticate as user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Test DELETE ICs // Test DELETE ICs
// This should fail with unprocessable entity status code 422 // This should fail with unprocessable entity status code 422
newIC1.WebsocketURL = "ThisIsMyNewURL3" newIC1.WebsocketURL = "ThisIsMyNewURL3"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v", newICID), "DELETE", nil) fmt.Sprintf("/api/v2/ic/%v", newICID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
} }
@ -532,43 +525,41 @@ func TestGetAllICs(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newICA // test POST ic/ $newICA
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// test POST ic/ $newICB // test POST ic/ $newICB
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// get the length of the GET all ICs response again // get the length of the GET all ICs response again
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+2) assert.Equal(t, finalNumber, initialNumber+2)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all ICs response again // get the length of the GET all ICs response again
finalNumber2, err := helper.LengthOfResponse(router, token, finalNumber2, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber2, initialNumber+2) assert.Equal(t, finalNumber2, initialNumber+2)
@ -580,13 +571,12 @@ func TestGetConfigsOfIC(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newICA // test POST ic/ $newICA
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -596,20 +586,19 @@ func TestGetConfigsOfIC(t *testing.T) {
// test GET ic/ID/confis // test GET ic/ID/confis
numberOfConfigs, err := helper.LengthOfResponse(router, token, numberOfConfigs, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/ic/%v/configs", newICID), "GET", nil) fmt.Sprintf("/api/v2/ic/%v/configs", newICID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
assert.Equal(t, 0, numberOfConfigs) assert.Equal(t, 0, numberOfConfigs)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test GET ic/ID/configs // test GET ic/ID/configs
numberOfConfigs, err = helper.LengthOfResponse(router, token, numberOfConfigs, err = helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/ic/%v/configs", newICID), "GET", nil) fmt.Sprintf("/api/v2/ic/%v/configs", newICID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -618,7 +607,7 @@ func TestGetConfigsOfIC(t *testing.T) {
// Try to get configs of IC that does not exist // Try to get configs of IC that does not exist
// should result in not found // should result in not found
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v/configs", newICID+1), "GET", nil) fmt.Sprintf("/api/v2/ic/%v/configs", newICID+1), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
} }
@ -629,13 +618,12 @@ func TestSendActionToIC(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST ic/ $newICA // test POST ic/ $newICA
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newIC1}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newIC1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -654,13 +642,13 @@ func TestSendActionToIC(t *testing.T) {
// Send action to IC // Send action to IC
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v/action", newICID), "POST", actions) fmt.Sprintf("/api/v2/ic/%v/action", newICID), "POST", actions)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Send malformed actions array to IC (should yield bad request) // Send malformed actions array to IC (should yield bad request)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/ic/%v/action", newICID), "POST", action1) fmt.Sprintf("/api/v2/ic/%v/action", newICID), "POST", action1)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
} }
@ -672,8 +660,7 @@ func TestCreateUpdateViaAMQPRecv(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// fake an IC update message // fake an IC update message
@ -711,7 +698,7 @@ func TestCreateUpdateViaAMQPRecv(t *testing.T) {
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err := helper.LengthOfResponse(router, token, number, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 0, number) assert.Equal(t, 0, number)
@ -753,7 +740,7 @@ func TestCreateUpdateViaAMQPRecv(t *testing.T) {
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err = helper.LengthOfResponse(router, token, number, err = helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 1, number) assert.Equal(t, 1, number)
@ -782,7 +769,7 @@ func TestCreateUpdateViaAMQPRecv(t *testing.T) {
time.Sleep(waitingTime * time.Second) time.Sleep(waitingTime * time.Second)
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err = helper.LengthOfResponse(router, token, number, err = helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 1, number) assert.Equal(t, 1, number)
@ -795,8 +782,7 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// fake an IC update message // fake an IC update message
@ -842,7 +828,7 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err := helper.LengthOfResponse(router, token, number, err := helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 1, number) assert.Equal(t, 1, number)
@ -854,7 +840,7 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -876,7 +862,7 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/configs", "POST", helper.KeyModels{"config": newConfig}) "/api/v2/configs", "POST", helper.KeyModels{"config": newConfig})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -915,13 +901,13 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err = helper.LengthOfResponse(router, token, number, err = helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 1, number) assert.Equal(t, 1, number)
// Delete component config from earlier // Delete component config from earlier
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/configs/%v", newConfigID), "DELETE", nil) fmt.Sprintf("/api/v2/configs/%v", newConfigID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -931,7 +917,7 @@ func TestDeleteICViaAMQPRecv(t *testing.T) {
// get the length of the GET all ICs response for user // get the length of the GET all ICs response for user
number, err = helper.LengthOfResponse(router, token, number, err = helper.LengthOfResponse(router, token,
"/api/ic", "GET", nil) "/api/v2/ic", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 0, number) assert.Equal(t, 0, number)
} }

9
routes/register.go
View file

@ -125,13 +125,6 @@ func ReadTestDataFromJson(path string) error {
// Uses API endpoints to add test data to the backend; All endpoints have to be registered before invoking this function. // Uses API endpoints to add test data to the backend; All endpoints have to be registered before invoking this function.
func AddTestData(cfg *config.Config, router *gin.Engine) (*bytes.Buffer, error) { func AddTestData(cfg *config.Config, router *gin.Engine) (*bytes.Buffer, error) {
basePath, err := cfg.String("base.path")
if err != nil {
fmt.Println("error: testdata could not be added to DB: no base path specified")
return nil, err
}
database.MigrateModels() database.MigrateModels()
// add Admin user (defaults to User_0, xyz789) // add Admin user (defaults to User_0, xyz789)
@ -147,7 +140,7 @@ func AddTestData(cfg *config.Config, router *gin.Engine) (*bytes.Buffer, error)
} }
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, basePath+"/authenticate", "POST", Admin) token, err := helper.AuthenticateForTest(router, Admin)
if err != nil { if err != nil {
return nil, err return nil, err
} }

6
routes/register_test.go
View file

@ -23,10 +23,11 @@
package routes package routes
import ( import (
infrastructure_component "git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/infrastructure-component"
"os" "os"
"testing" "testing"
infrastructure_component "git.rwth-aachen.de/acs/public/villas/web-backend-go/routes/infrastructure-component"
"git.rwth-aachen.de/acs/public/villas/web-backend-go/configuration" "git.rwth-aachen.de/acs/public/villas/web-backend-go/configuration"
"git.rwth-aachen.de/acs/public/villas/web-backend-go/database" "git.rwth-aachen.de/acs/public/villas/web-backend-go/database"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@ -50,8 +51,7 @@ func TestMain(m *testing.M) {
router = gin.Default() router = gin.Default()
basePath, _ := configuration.GlobalConfig.String("base.path") api = router.Group("/api/v2")
api = router.Group(basePath)
os.Exit(m.Run()) os.Exit(m.Run())
} }

46
routes/result/result_test.go
View file

@ -46,8 +46,8 @@ import (
) )
var router *gin.Engine var router *gin.Engine
var base_api_results = "/api/results" var base_api_results = "/api/v2/results"
var base_api_auth = "/api/authenticate" var base_api_auth = "/api/v2/authenticate"
type ScenarioRequest struct { type ScenarioRequest struct {
Name string `json:"name,omitempty"` Name string `json:"name,omitempty"`
@ -72,12 +72,10 @@ var newResult = ResultRequest{
func addScenario() (scenarioID uint) { func addScenario() (scenarioID uint) {
// authenticate as admin // authenticate as admin
token, _ := helper.AuthenticateForTest(router, token, _ := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
// authenticate as normal user // authenticate as normal user
token, _ = helper.AuthenticateForTest(router, token, _ = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
// POST $newScenario // POST $newScenario
newScenario := ScenarioRequest{ newScenario := ScenarioRequest{
@ -86,14 +84,14 @@ func addScenario() (scenarioID uint) {
StartParameters: postgres.Jsonb{RawMessage: json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{RawMessage: json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
_, resp, _ := helper.TestEndpoint(router, token, _, resp, _ := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
// Read newScenario's ID from the response // Read newScenario's ID from the response
newScenarioID, _ := helper.GetResponseID(resp) newScenarioID, _ := helper.GetResponseID(resp)
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID) return uint(newScenarioID)
} }
@ -110,7 +108,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -135,8 +133,7 @@ func TestGetAllResultsOfScenario(t *testing.T) {
scenarioID := addScenario() scenarioID := addScenario()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newResult // test POST newResult
@ -158,8 +155,7 @@ func TestGetAllResultsOfScenario(t *testing.T) {
assert.Equal(t, 1, NumberOfConfigs) assert.Equal(t, 1, NumberOfConfigs)
// authenticate as normal userB who has no access to scenario // authenticate as normal userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get results without access // try to get results without access
@ -185,8 +181,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
newResult.ScenarioID = scenarioID newResult.ScenarioID = scenarioID
newResult.ConfigSnapshots = confSnapshots newResult.ConfigSnapshots = confSnapshots
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST with no access // try to POST with no access
@ -197,8 +192,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST non JSON body // try to POST non JSON body
@ -243,8 +237,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Try to GET the newResult with no access // Try to GET the newResult with no access
@ -269,8 +262,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as guest user who has access to result // authenticate as guest user who has access to result
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
base_api_auth, "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT as guest // try to PUT as guest
@ -281,8 +273,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT a non JSON body // try to PUT a non JSON body
@ -312,8 +303,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
newResult.Description = updatedResult.Description newResult.Description = updatedResult.Description
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
base_api_auth, "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE with no access // try to DELETE with no access
@ -324,8 +314,7 @@ func TestAddGetUpdateDeleteResult(t *testing.T) {
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the results returned for scenario // Count the number of all the results returned for scenario
@ -366,8 +355,7 @@ func TestAddDeleteResultFile(t *testing.T) {
newResult.ScenarioID = scenarioID newResult.ScenarioID = scenarioID
newResult.ConfigSnapshots = confSnapshots newResult.ConfigSnapshots = confSnapshots
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
base_api_auth, "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST newResult // test POST newResult

180
routes/scenario/scenario_test.go
View file

@ -77,7 +77,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -96,20 +96,19 @@ func TestAddScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST with non JSON body // try to POST with non JSON body
// should return a bad request error // should return a bad request error
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", "this is not a JSON") "/api/v2/scenarios", "POST", "this is not a JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// test POST scenarios/ $newScenario as normal user // test POST scenarios/ $newScenario as normal user
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -123,7 +122,7 @@ func TestAddScenario(t *testing.T) {
// Get the newScenario // Get the newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -138,49 +137,46 @@ func TestAddScenario(t *testing.T) {
} }
// this should NOT work and return a unprocessable entity 442 status code // this should NOT work and return a unprocessable entity 442 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": malformedNewScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": malformedNewScenario})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// try to GET a non-existing scenario // try to GET a non-existing scenario
// should return a not found 404 // should return a not found 404
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID+1), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID+1), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// authenticate as guest user // authenticate as guest user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to add scenario as guest user // try to add scenario as guest user
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as userB who has no access to the added scenario // authenticate as userB who has no access to the added scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to GET a scenario to which user B has no access // try to GET a scenario to which user B has no access
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as admin user who has no access to everything // authenticate as admin user who has no access to everything
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to GET a scenario that is not created by admin user; should work anyway // try to GET a scenario that is not created by admin user; should work anyway
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
} }
@ -192,13 +188,12 @@ func TestUpdateScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario // test POST scenarios/ $newScenario
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -219,12 +214,12 @@ func TestUpdateScenario(t *testing.T) {
// try to update with non JSON body // try to update with non JSON body
// should return a bad request error // should return a bad request error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "PUT", "This is not a JSON body") fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "PUT", "This is not a JSON body")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "PUT", helper.KeyModels{"scenario": updatedScenario}) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "PUT", helper.KeyModels{"scenario": updatedScenario})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -234,7 +229,7 @@ func TestUpdateScenario(t *testing.T) {
// Get the updatedScenario // Get the updatedScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -244,7 +239,7 @@ func TestUpdateScenario(t *testing.T) {
// try to update a scenario that does not exist (should return not found 404 status code) // try to update a scenario that does not exist (should return not found 404 status code)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID+1), "PUT", helper.KeyModels{"scenario": updatedScenario}) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID+1), "PUT", helper.KeyModels{"scenario": updatedScenario})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
@ -257,45 +252,41 @@ func TestGetAllScenariosAsAdmin(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all scenarios response for admin // get the length of the GET all scenarios response for admin
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as normal userB // authenticate as normal userB
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario1 // test POST scenarios/ $newScenario1
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as normal userA // authenticate as normal userA
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario2 // test POST scenarios/ $newScenario2
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario2}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario2})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as admin // authenticate as admin
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all scenarios response again // get the length of the GET all scenarios response again
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+2) assert.Equal(t, finalNumber, initialNumber+2)
@ -308,40 +299,37 @@ func TestGetAllScenariosAsUser(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal userB // authenticate as normal userB
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all scenarios response for userB // get the length of the GET all scenarios response for userB
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario2 // test POST scenarios/ $newScenario2
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario2}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario2})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as normal userA // authenticate as normal userA
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario1 // test POST scenarios/ $newScenario1
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as normal userB // authenticate as normal userB
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all scenarios response again // get the length of the GET all scenarios response again
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+1) assert.Equal(t, finalNumber, initialNumber+1)
@ -354,13 +342,12 @@ func TestDeleteScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario // test POST scenarios/ $newScenario
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -370,35 +357,33 @@ func TestDeleteScenario(t *testing.T) {
// add guest user to new scenario // add guest user to new scenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as guest user // authenticate as guest user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to delete scenario as guest // try to delete scenario as guest
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the scenarios returned for userA // Count the number of all the scenarios returned for userA
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added newScenario // Delete the added newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -408,7 +393,7 @@ func TestDeleteScenario(t *testing.T) {
// Again count the number of all the scenarios returned // Again count the number of all the scenarios returned
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/scenarios", "GET", nil) "/api/v2/scenarios", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber-1) assert.Equal(t, finalNumber, initialNumber-1)
@ -421,13 +406,12 @@ func TestAddUserToScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario // test POST scenarios/ $newScenario
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -436,38 +420,36 @@ func TestAddUserToScenario(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to add new user User_C to scenario as userB // try to add new user User_C to scenario as userB
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// try to add new user UserB to scenario as userB // try to add new user UserB to scenario as userB
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the users returned for newScenario // Count the number of all the users returned for newScenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber, 1) assert.Equal(t, initialNumber, 1)
// add userB to newScenario // add userB to newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -482,13 +464,13 @@ func TestAddUserToScenario(t *testing.T) {
// Count AGAIN the number of all the users returned for newScenario // Count AGAIN the number of all the users returned for newScenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+1) assert.Equal(t, finalNumber, initialNumber+1)
// try to add a non-existing user to newScenario, should return a not found 404 // try to add a non-existing user to newScenario, should return a not found 404
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_D", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_D", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
@ -501,13 +483,12 @@ func TestGetAllUsersOfScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario // test POST scenarios/ $newScenario
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -516,60 +497,56 @@ func TestGetAllUsersOfScenario(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get all users of new scenario with userB // try to get all users of new scenario with userB
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the users returned for newScenario // Count the number of all the users returned for newScenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber, 1) assert.Equal(t, initialNumber, 1)
// add userB to newScenario // add userB to newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_B", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Count AGAIN the number of all the users returned for newScenario // Count AGAIN the number of all the users returned for newScenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+1) assert.Equal(t, finalNumber, initialNumber+1)
// authenticate as admin // authenticate as admin
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// set userB as inactive // set userB as inactive
modUserB := UserRequest{Active: "no"} modUserB := UserRequest{Active: "no"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", 3), "PUT", helper.KeyModels{"user": modUserB}) fmt.Sprintf("/api/v2/users/%v", 3), "PUT", helper.KeyModels{"user": modUserB})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count AGAIN the number of all the users returned for newScenario // Count AGAIN the number of all the users returned for newScenario
finalNumber2, err := helper.LengthOfResponse(router, token, finalNumber2, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber2, initialNumber) assert.Equal(t, finalNumber2, initialNumber)
} }
@ -581,13 +558,12 @@ func TestRemoveUserFromScenario(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST scenarios/ $newScenario // test POST scenarios/ $newScenario
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario1}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -597,36 +573,34 @@ func TestRemoveUserFromScenario(t *testing.T) {
// add userC to newScenario // add userC to newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to delete userC from new scenario // try to delete userC from new scenario
// should return an unprocessable entity error // should return an unprocessable entity error
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the users returned for newScenario // Count the number of all the users returned for newScenario
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, 2, initialNumber) assert.Equal(t, 2, initialNumber)
// remove userC from newScenario // remove userC from newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -641,28 +615,28 @@ func TestRemoveUserFromScenario(t *testing.T) {
// Count AGAIN the number of all the users returned for newScenario // Count AGAIN the number of all the users returned for newScenario
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/scenarios/%v/users", newScenarioID), "GET", nil) fmt.Sprintf("/api/v2/scenarios/%v/users", newScenarioID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber-1, finalNumber) assert.Equal(t, initialNumber-1, finalNumber)
// Try to remove userA from new scenario // Try to remove userA from new scenario
// This should fail since User_A is the last user of newScenario // This should fail since User_A is the last user of newScenario
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_A", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_A", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 500, code, "Response body: \n%v\n", resp) assert.Equalf(t, 500, code, "Response body: \n%v\n", resp)
// Try to remove a user that does not exist in DB // Try to remove a user that does not exist in DB
// This should fail with not found 404 status code // This should fail with not found 404 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_D", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_D", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// Try to remove an admin user that is not explicitly a user of the scenario // Try to remove an admin user that is not explicitly a user of the scenario
// This should fail with not found 404 status code // This should fail with not found 404 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_0", newScenarioID), "DELETE", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_0", newScenarioID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)

113
routes/signal/signal_test.go
View file

@ -91,8 +91,7 @@ func newFalse() *bool {
func addScenarioAndICAndConfig() (scenarioID uint, ICID uint, configID uint) { func addScenarioAndICAndConfig() (scenarioID uint, ICID uint, configID uint) {
// authenticate as admin // authenticate as admin
token, _ := helper.AuthenticateForTest(router, token, _ := helper.AuthenticateForTest(router, helper.AdminCredentials)
"/api/authenticate", "POST", helper.AdminCredentials)
// POST $newICA // POST $newICA
newICA := ICRequest{ newICA := ICRequest{
@ -108,14 +107,13 @@ func addScenarioAndICAndConfig() (scenarioID uint, ICID uint, configID uint) {
ManagedExternally: newFalse(), ManagedExternally: newFalse(),
} }
_, resp, _ := helper.TestEndpoint(router, token, _, resp, _ := helper.TestEndpoint(router, token,
"/api/ic", "POST", helper.KeyModels{"ic": newICA}) "/api/v2/ic", "POST", helper.KeyModels{"ic": newICA})
// Read newIC's ID from the response // Read newIC's ID from the response
newICID, _ := helper.GetResponseID(resp) newICID, _ := helper.GetResponseID(resp)
// authenticate as normal user // authenticate as normal user
token, _ = helper.AuthenticateForTest(router, token, _ = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
// POST $newScenario // POST $newScenario
newScenario := ScenarioRequest{ newScenario := ScenarioRequest{
@ -124,7 +122,7 @@ func addScenarioAndICAndConfig() (scenarioID uint, ICID uint, configID uint) {
StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
// Read newScenario's ID from the response // Read newScenario's ID from the response
newScenarioID, _ := helper.GetResponseID(resp) newScenarioID, _ := helper.GetResponseID(resp)
@ -137,14 +135,14 @@ func addScenarioAndICAndConfig() (scenarioID uint, ICID uint, configID uint) {
ICID: uint(newICID), ICID: uint(newICID),
} }
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
"/api/configs", "POST", helper.KeyModels{"config": newConfig}) "/api/v2/configs", "POST", helper.KeyModels{"config": newConfig})
// Read newConfig's ID from the response // Read newConfig's ID from the response
newConfigID, _ := helper.GetResponseID(resp) newConfigID, _ := helper.GetResponseID(resp)
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID), uint(newICID), uint(newConfigID) return uint(newScenarioID), uint(newICID), uint(newConfigID)
} }
@ -162,7 +160,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -191,38 +189,35 @@ func TestAddSignal(t *testing.T) {
_, _, configID := addScenarioAndICAndConfig() _, _, configID := addScenarioAndICAndConfig()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
newSignal1.ConfigID = configID newSignal1.ConfigID = configID
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST to component config without access // try to POST to component config without access
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal1}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST a signal with non JSON body // try to POST a signal with non JSON body
// should result in a bad request // should result in a bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", "this is not a JSON") "/api/v2/signals", "POST", "this is not a JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// test POST signals/ $newSignal // test POST signals/ $newSignal
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal1}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -236,7 +231,7 @@ func TestAddSignal(t *testing.T) {
// Get the newSignal // Get the newSignal
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "GET", nil) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -251,19 +246,18 @@ func TestAddSignal(t *testing.T) {
} }
// this should NOT work and return a unprocessable entity 442 status code // this should NOT work and return a unprocessable entity 442 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": malformedNewSignal}) "/api/v2/signals", "POST", helper.KeyModels{"signal": malformedNewSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Try to Get the newSignal as user B // Try to Get the newSignal as user B
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "GET", nil) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
} }
@ -279,14 +273,13 @@ func TestUpdateSignal(t *testing.T) {
_, _, configID := addScenarioAndICAndConfig() _, _, configID := addScenarioAndICAndConfig()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST signals/ $newSignal // test POST signals/ $newSignal
newSignal1.ConfigID = configID newSignal1.ConfigID = configID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal1}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -301,44 +294,41 @@ func TestUpdateSignal(t *testing.T) {
} }
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT signal without access // try to PUT signal without access
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal}) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as guest user // authenticate as guest user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to update signal as guest who has access to scenario // try to update signal as guest who has access to scenario
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal}) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT with non JSON body // try to PUT with non JSON body
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "PUT", "This is not JSON") fmt.Sprintf("/api/v2/signals/%v", newSignalID), "PUT", "This is not JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// test PUT // test PUT
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal}) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "PUT", helper.KeyModels{"signal": updatedSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -348,7 +338,7 @@ func TestUpdateSignal(t *testing.T) {
// Get the updatedSignal // Get the updatedSignal
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "GET", nil) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -358,7 +348,7 @@ func TestUpdateSignal(t *testing.T) {
// try to update a signal that does not exist (should return not found 404 status code) // try to update a signal that does not exist (should return not found 404 status code)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID+1), "PUT", helper.KeyModels{"signal": updatedSignal}) fmt.Sprintf("/api/v2/signals/%v", newSignalID+1), "PUT", helper.KeyModels{"signal": updatedSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
@ -375,8 +365,7 @@ func TestDeleteSignal(t *testing.T) {
_, _, configID := addScenarioAndICAndConfig() _, _, configID := addScenarioAndICAndConfig()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// test POST signals/ $newSignal // test POST signals/ $newSignal
@ -388,7 +377,7 @@ func TestDeleteSignal(t *testing.T) {
ConfigID: configID, ConfigID: configID,
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -397,31 +386,29 @@ func TestDeleteSignal(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Try to DELETE signal with no access // Try to DELETE signal with no access
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "DELETE", nil) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the input signals returned for component config // Count the number of all the input signals returned for component config
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=in", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=in", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// add an output signal to make sure that counting of input signals works // add an output signal to make sure that counting of input signals works
newSignal1.ConfigID = configID newSignal1.ConfigID = configID
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal1}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -431,7 +418,7 @@ func TestDeleteSignal(t *testing.T) {
// Delete the added newSignal // Delete the added newSignal
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignalID), "DELETE", nil) fmt.Sprintf("/api/v2/signals/%v", newSignalID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -441,14 +428,14 @@ func TestDeleteSignal(t *testing.T) {
// Again count the number of all the input signals returned for component config // Again count the number of all the input signals returned for component config
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=in", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=in", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber-1, finalNumber) assert.Equal(t, initialNumber-1, finalNumber)
// Delete the output signal // Delete the output signal
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals/%v", newSignaloutID), "DELETE", nil) fmt.Sprintf("/api/v2/signals/%v", newSignaloutID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
} }
@ -464,13 +451,12 @@ func TestGetAllInputSignalsOfConfig(t *testing.T) {
_, _, configID := addScenarioAndICAndConfig() _, _, configID := addScenarioAndICAndConfig()
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the input signals returned for component config // Count the number of all the input signals returned for component config
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=in", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=in", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// test POST signals/ $newSignal // test POST signals/ $newSignal
@ -482,7 +468,7 @@ func TestGetAllInputSignalsOfConfig(t *testing.T) {
ConfigID: configID, ConfigID: configID,
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignalA}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignalA})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -495,14 +481,14 @@ func TestGetAllInputSignalsOfConfig(t *testing.T) {
ConfigID: configID, ConfigID: configID,
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignalB}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignalB})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// add an output signal // add an output signal
newSignal1.ConfigID = configID newSignal1.ConfigID = configID
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignal1}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignal1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -515,39 +501,38 @@ func TestGetAllInputSignalsOfConfig(t *testing.T) {
ConfigID: configID, ConfigID: configID,
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/signals", "POST", helper.KeyModels{"signal": newSignalBout}) "/api/v2/signals", "POST", helper.KeyModels{"signal": newSignalBout})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Again count the number of all the input signals returned for component config // Again count the number of all the input signals returned for component config
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=in", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=in", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber+2, finalNumber) assert.Equal(t, initialNumber+2, finalNumber)
// Get the number of output signals // Get the number of output signals
outputNumber, err := helper.LengthOfResponse(router, token, outputNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=out", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=out", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber+2, outputNumber) assert.Equal(t, initialNumber+2, outputNumber)
// Try to get all signals for non-existing direction // Try to get all signals for non-existing direction
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=thisiswrong", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=thisiswrong", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// authenticate as normal userB who has no access to new scenario // authenticate as normal userB who has no access to new scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get all input signals // try to get all input signals
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/signals?configID=%v&direction=in", configID), "GET", nil) fmt.Sprintf("/api/v2/signals?configID=%v&direction=in", configID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)

10
routes/user/authenticate_endpoint.go
View file

@ -46,13 +46,13 @@ func RegisterAuthenticate(r *gin.RouterGroup) {
// authenticated godoc // authenticated godoc
// @Summary Check if user is authenticated and provide details on how the user can authenticate // @Summary Check if user is authenticated and provide details on how the user can authenticate
// @ID authenticate // @ID authenticated
// @Accept json // @Accept json
// @Produce json // @Produce json
// @Tags authentication // @Tags authentication
// @Success 200 {object} docs.ResponseAuthenticate "JSON web token, success status, message and authenticated user object" // @Success 200 {object} api.ResponseAuthenticate "JSON web token, success status, message and authenticated user object"
// @Failure 401 {object} docs.ResponseError "Unauthorized" // @Failure 401 {object} api.ResponseError "Unauthorized"
// @Failure 500 {object} docs.ResponseError "Internal server error." // @Failure 500 {object} api.ResponseError "Internal server error."
// @Router /authenticate [get] // @Router /authenticate [get]
func authenticated(c *gin.Context) { func authenticated(c *gin.Context) {
ok, err := isAuthenticated(c) ok, err := isAuthenticated(c)
@ -109,7 +109,7 @@ func authenticated(c *gin.Context) {
// @Success 200 {object} api.ResponseAuthenticate "JSON web token, success status, message and authenticated user object" // @Success 200 {object} api.ResponseAuthenticate "JSON web token, success status, message and authenticated user object"
// @Failure 401 {object} api.ResponseError "Unauthorized" // @Failure 401 {object} api.ResponseError "Unauthorized"
// @Failure 500 {object} api.ResponseError "Internal server error." // @Failure 500 {object} api.ResponseError "Internal server error."
// @Router /authenticate{mechanism} [post] // @Router /authenticate/{mechanism} [post]
func authenticate(c *gin.Context) { func authenticate(c *gin.Context) {
var user *User = nil var user *User = nil

187
routes/user/user_test.go
View file

@ -25,7 +25,6 @@ import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"fmt" "fmt"
"log"
"net/http" "net/http"
"net/http/httptest" "net/http/httptest"
"os" "os"
@ -63,7 +62,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
RegisterAuthenticate(api.Group("/authenticate")) RegisterAuthenticate(api.Group("/authenticate"))
api.Use(Authentication()) api.Use(Authentication())
@ -82,7 +81,7 @@ func TestAuthenticate(t *testing.T) {
// should result in unauthorized // should result in unauthorized
w1 := httptest.NewRecorder() w1 := httptest.NewRecorder()
body, _ := json.Marshal("This is no JSON") body, _ := json.Marshal("This is no JSON")
req, err := http.NewRequest("POST", "/api/authenticate", bytes.NewBuffer(body)) req, err := http.NewRequest("POST", "/api/v2/authenticate", bytes.NewBuffer(body))
assert.NoError(t, err) assert.NoError(t, err)
req.Header.Set("Content-Type", "application/json") req.Header.Set("Content-Type", "application/json")
router.ServeHTTP(w1, req) router.ServeHTTP(w1, req)
@ -95,7 +94,7 @@ func TestAuthenticate(t *testing.T) {
// should result in unauthorized // should result in unauthorized
w2 := httptest.NewRecorder() w2 := httptest.NewRecorder()
body, _ = json.Marshal(malformedCredentials) body, _ = json.Marshal(malformedCredentials)
req, err = http.NewRequest("POST", "/api/authenticate", bytes.NewBuffer(body)) req, err = http.NewRequest("POST", "/api/v2/authenticate", bytes.NewBuffer(body))
assert.NoError(t, err) assert.NoError(t, err)
req.Header.Set("Content-Type", "application/json") req.Header.Set("Content-Type", "application/json")
router.ServeHTTP(w2, req) router.ServeHTTP(w2, req)
@ -107,7 +106,7 @@ func TestAuthenticate(t *testing.T) {
malformedCredentials.Password = "blablabla" malformedCredentials.Password = "blablabla"
w3 := httptest.NewRecorder() w3 := httptest.NewRecorder()
body, _ = json.Marshal(malformedCredentials) body, _ = json.Marshal(malformedCredentials)
req, err = http.NewRequest("POST", "/api/authenticate", bytes.NewBuffer(body)) req, err = http.NewRequest("POST", "/api/v2/authenticate", bytes.NewBuffer(body))
assert.NoError(t, err) assert.NoError(t, err)
req.Header.Set("Content-Type", "application/json") req.Header.Set("Content-Type", "application/json")
router.ServeHTTP(w3, req) router.ServeHTTP(w3, req)
@ -119,16 +118,14 @@ func TestAuthenticate(t *testing.T) {
malformedCredentials.Password = "wrong password" malformedCredentials.Password = "wrong password"
w4 := httptest.NewRecorder() w4 := httptest.NewRecorder()
body, _ = json.Marshal(malformedCredentials) body, _ = json.Marshal(malformedCredentials)
req, err = http.NewRequest("POST", "/api/authenticate", bytes.NewBuffer(body)) req, err = http.NewRequest("POST", "/api/v2/authenticate", bytes.NewBuffer(body))
assert.NoError(t, err) assert.NoError(t, err)
req.Header.Set("Content-Type", "application/json") req.Header.Set("Content-Type", "application/json")
router.ServeHTTP(w4, req) router.ServeHTTP(w4, req)
assert.Equal(t, 401, w4.Code, w4.Body) assert.Equal(t, 401, w4.Code, w4.Body)
// authenticate as admin // authenticate as admin
log.Println(helper.AdminCredentials) _, err = helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
_, err = helper.AuthenticateForTest(router,
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
} }
@ -141,14 +138,13 @@ func TestAuthenticateQueryToken(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
w := httptest.NewRecorder() w := httptest.NewRecorder()
// Create the request // Create the request
req, err := http.NewRequest("GET", "/api/users?token="+token, nil) req, err := http.NewRequest("GET", "/api/v2/users?token="+token, nil)
assert.NoError(t, err) assert.NoError(t, err)
router.ServeHTTP(w, req) router.ServeHTTP(w, req)
@ -163,14 +159,13 @@ func TestAddGetUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// try to POST with non JSON body // try to POST with non JSON body
// should result in bad request // should result in bad request
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", "This is not JSON") "/api/v2/users", "POST", "This is not JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -183,7 +178,7 @@ func TestAddGetUser(t *testing.T) {
// try POST with too short username // try POST with too short username
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -192,7 +187,7 @@ func TestAddGetUser(t *testing.T) {
wrongUser.Username = "Longenoughusername" wrongUser.Username = "Longenoughusername"
wrongUser.Password = "short" wrongUser.Password = "short"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -201,7 +196,7 @@ func TestAddGetUser(t *testing.T) {
wrongUser.Password = "longenough" wrongUser.Password = "longenough"
wrongUser.Role = "ThisIsNotARole" wrongUser.Role = "ThisIsNotARole"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -210,7 +205,7 @@ func TestAddGetUser(t *testing.T) {
wrongUser.Mail = "noemailaddress" wrongUser.Mail = "noemailaddress"
wrongUser.Role = "Guest" wrongUser.Role = "Guest"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -220,7 +215,7 @@ func TestAddGetUser(t *testing.T) {
wrongUser.Role = "" wrongUser.Role = ""
wrongUser.Password = "" wrongUser.Password = ""
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -231,7 +226,7 @@ func TestAddGetUser(t *testing.T) {
wrongUser.Password = "blablabla" wrongUser.Password = "blablabla"
wrongUser.Username = "admin" wrongUser.Username = "admin"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": wrongUser}) "/api/v2/users", "POST", helper.KeyModels{"user": wrongUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -244,7 +239,7 @@ func TestAddGetUser(t *testing.T) {
// test POST user/ $newUser // test POST user/ $newUser
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -264,7 +259,7 @@ func TestAddGetUser(t *testing.T) {
// Get the newUser // Get the newUser
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "GET", nil) fmt.Sprintf("/api/v2/users/%v", newUserID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -275,7 +270,7 @@ func TestAddGetUser(t *testing.T) {
// try to GET user with invalid user ID // try to GET user with invalid user ID
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/bla"), "GET", nil) fmt.Sprintf("/api/v2/users/bla"), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
} }
@ -288,8 +283,7 @@ func TestUsersNotAllowedActions(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// Add a user // Add a user
@ -300,7 +294,7 @@ func TestUsersNotAllowedActions(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -308,34 +302,33 @@ func TestUsersNotAllowedActions(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// Authenticate as the added user // Authenticate as the added user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, UserRequest{
"/api/authenticate", "POST", UserRequest{ Username: newUser.Username,
Username: newUser.Username, Password: newUser.Password,
Password: newUser.Password, })
})
assert.NoError(t, err) assert.NoError(t, err)
// Try to get all the users (NOT ALLOWED) // Try to get all the users (NOT ALLOWED)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// Try to read another user than self (eg. Admin) (NOT ALLOWED) // Try to read another user than self (eg. Admin) (NOT ALLOWED)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users/0", "GET", nil) "/api/v2/users/0", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
// Try to delete another user (eg. Admin) (NOT ALLOWED) // Try to delete another user (eg. Admin) (NOT ALLOWED)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users/0", "DELETE", nil) "/api/v2/users/0", "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// Try to delete self (NOT ALLOWED) // Try to delete self (NOT ALLOWED)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "DELETE", nil) fmt.Sprintf("/api/v2/users/%v", newUserID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -349,13 +342,12 @@ func TestGetAllUsers(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// get the length of the GET all users response // get the length of the GET all users response
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/users", "GET", nil) "/api/v2/users", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Add a user // Add a user
@ -366,13 +358,13 @@ func TestGetAllUsers(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// get the length of the GET all users response again // get the length of the GET all users response again
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/users", "GET", nil) "/api/v2/users", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber+1) assert.Equal(t, finalNumber, initialNumber+1)
@ -383,14 +375,13 @@ func TestGetAllUsers(t *testing.T) {
} }
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, newUserCredentials)
"/api/authenticate", "POST", newUserCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to get all users as normal user // try to get all users as normal user
// should result in unprocessable entity eror // should result in unprocessable entity eror
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users", "GET", nil) "/api/v2/users", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
@ -404,8 +395,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// Add a user that will modify itself // Add a user that will modify itself
@ -416,7 +406,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -424,16 +414,15 @@ func TestModifyAddedUserAsUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as the new user // authenticate as the new user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, UserRequest{
"/api/authenticate", "POST", UserRequest{ Username: newUser.Username,
Username: newUser.Username, Password: newUser.Password,
Password: newUser.Password, })
})
assert.NoError(t, err) assert.NoError(t, err)
// Try PUT with invalid user ID in path // Try PUT with invalid user ID in path
// Should return a bad request // Should return a bad request
code, resp, err = helper.TestEndpoint(router, token, fmt.Sprintf("/api/users/blabla"), "PUT", code, resp, err = helper.TestEndpoint(router, token, fmt.Sprintf("/api/v2/users/blabla"), "PUT",
helper.KeyModels{"user": newUser}) helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -441,7 +430,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
// Try to PUT a non JSON body // Try to PUT a non JSON body
// Should return a bad request // Should return a bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", "This is no JSON") fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT", "This is no JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -455,7 +444,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
// should result in forbidden // should result in forbidden
modActiveState := UserRequest{Active: "no"} modActiveState := UserRequest{Active: "no"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", helper.KeyModels{"user": modActiveState}) fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT", helper.KeyModels{"user": modActiveState})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
@ -463,7 +452,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
modRequest := UserRequest{Username: "myNewName"} modRequest := UserRequest{Username: "myNewName"}
newUser.Username = modRequest.Username newUser.Username = modRequest.Username
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -474,7 +463,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
modRequest = UserRequest{Username: "myNewName"} modRequest = UserRequest{Username: "myNewName"}
newUser.Username = modRequest.Username newUser.Username = modRequest.Username
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users/1", "PUT", helper.KeyModels{"user": modRequest}) "/api/v2/users/1", "PUT", helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
@ -482,7 +471,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
modRequest = UserRequest{Mail: "my@new.email"} modRequest = UserRequest{Mail: "my@new.email"}
newUser.Mail = modRequest.Mail newUser.Mail = modRequest.Mail
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -493,7 +482,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
modRequest = UserRequest{Mail: "my@new.email"} modRequest = UserRequest{Mail: "my@new.email"}
newUser.Mail = modRequest.Mail newUser.Mail = modRequest.Mail
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users/1", "PUT", helper.KeyModels{"user": modRequest}) "/api/v2/users/1", "PUT", helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
@ -501,7 +490,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
modRequest = UserRequest{Role: "Admin"} modRequest = UserRequest{Role: "Admin"}
newUser.Role = modRequest.Role newUser.Role = modRequest.Role
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
@ -511,7 +500,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
Password: "5tr0ng_pw!", Password: "5tr0ng_pw!",
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -522,7 +511,7 @@ func TestModifyAddedUserAsUser(t *testing.T) {
OldPassword: "wrongoldpassword", OldPassword: "wrongoldpassword",
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
@ -533,23 +522,22 @@ func TestModifyAddedUserAsUser(t *testing.T) {
OldPassword: "mod_My5elf", OldPassword: "mod_My5elf",
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// try to login as newUser with the modified username and password // try to login as newUser with the modified username and password
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, UserRequest{
"/api/authenticate", "POST", UserRequest{ Username: newUser.Username,
Username: newUser.Username, Password: modRequest.Password,
Password: modRequest.Password, })
})
assert.NoError(t, err) assert.NoError(t, err)
// modify Admin's password (ILLEGAL) // modify Admin's password (ILLEGAL)
modRequest = UserRequest{Password: "4dm1ns_pw!"} modRequest = UserRequest{Password: "4dm1ns_pw!"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/users/1", "PUT", helper.KeyModels{"user": modRequest}) "/api/v2/users/1", "PUT", helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 403, code, "Response body: \n%v\n", resp) assert.Equalf(t, 403, code, "Response body: \n%v\n", resp)
} }
@ -562,8 +550,7 @@ func TestInvalidUserUpdate(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// Add a user // Add a user
@ -574,7 +561,7 @@ func TestInvalidUserUpdate(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -587,7 +574,7 @@ func TestInvalidUserUpdate(t *testing.T) {
Password: "longenough", Password: "longenough",
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID+1), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID+1), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
@ -597,7 +584,7 @@ func TestInvalidUserUpdate(t *testing.T) {
modRequest.Password = "" modRequest.Password = ""
modRequest.Username = "admin" modRequest.Username = "admin"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -605,7 +592,7 @@ func TestInvalidUserUpdate(t *testing.T) {
// modify newUser's password with INVALID password // modify newUser's password with INVALID password
modRequest.Password = "short" modRequest.Password = "short"
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -613,7 +600,7 @@ func TestInvalidUserUpdate(t *testing.T) {
// modify newUser's email with INVALID email // modify newUser's email with INVALID email
modRequest = UserRequest{Mail: "notEmail"} modRequest = UserRequest{Mail: "notEmail"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -621,7 +608,7 @@ func TestInvalidUserUpdate(t *testing.T) {
// modify newUser's role with INVALID role // modify newUser's role with INVALID role
modRequest = UserRequest{Role: "noRole"} modRequest = UserRequest{Role: "noRole"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -636,8 +623,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// Add a user // Add a user
@ -648,7 +634,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -665,7 +651,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
modRequest := UserRequest{Username: "NewUsername"} modRequest := UserRequest{Username: "NewUsername"}
newUser.Username = modRequest.Username newUser.Username = modRequest.Username
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -676,7 +662,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
modRequest = UserRequest{Mail: "new@e.mail"} modRequest = UserRequest{Mail: "new@e.mail"}
newUser.Mail = modRequest.Mail newUser.Mail = modRequest.Mail
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -687,7 +673,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
modRequest = UserRequest{Role: "Admin"} modRequest = UserRequest{Role: "Admin"}
newUser.Role = modRequest.Role newUser.Role = modRequest.Role
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -699,7 +685,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
Password: "4_g00d_pw!", Password: "4_g00d_pw!",
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
@ -710,28 +696,26 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
OldPassword: adminpw, OldPassword: adminpw,
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// try to login as newUser with the modified username and password // try to login as newUser with the modified username and password
_, err = helper.AuthenticateForTest(router, _, err = helper.AuthenticateForTest(router, UserRequest{
"/api/authenticate", "POST", UserRequest{ Username: newUser.Username,
Username: newUser.Username, Password: modRequest.Password,
Password: modRequest.Password, })
})
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// modify newUser's Active status // modify newUser's Active status
modRequest = UserRequest{Active: "no"} modRequest = UserRequest{Active: "no"}
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "PUT", fmt.Sprintf("/api/v2/users/%v", newUserID), "PUT",
helper.KeyModels{"user": modRequest}) helper.KeyModels{"user": modRequest})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -739,7 +723,7 @@ func TestModifyAddedUserAsAdmin(t *testing.T) {
// try to login as newUser with the modified active status // try to login as newUser with the modified active status
// should NOT work anymore! // should NOT work anymore!
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/authenticate", "POST", "/api/v2/authenticate", "POST",
UserRequest{ UserRequest{
Username: newUser.Username, Username: newUser.Username,
Password: "4_g00d_pw!", Password: "4_g00d_pw!",
@ -756,8 +740,7 @@ func TestDeleteUser(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as admin // authenticate as admin
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.Credentials{Username: "admin", Password: adminpw})
"/api/authenticate", "POST", helper.Credentials{Username: "admin", Password: adminpw})
assert.NoError(t, err) assert.NoError(t, err)
// Add a user // Add a user
@ -768,7 +751,7 @@ func TestDeleteUser(t *testing.T) {
Role: "User", Role: "User",
} }
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/users", "POST", helper.KeyModels{"user": newUser}) "/api/v2/users", "POST", helper.KeyModels{"user": newUser})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -778,31 +761,31 @@ func TestDeleteUser(t *testing.T) {
// try to DELETE with invalid ID // try to DELETE with invalid ID
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/bla"), "DELETE", nil) fmt.Sprintf("/api/v2/users/bla"), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// try to DELETE with ID that does not exist // try to DELETE with ID that does not exist
// should result in not found // should result in not found
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID+1), "DELETE", nil) fmt.Sprintf("/api/v2/users/%v", newUserID+1), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
// Count the number of all the users returned // Count the number of all the users returned
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
"/api/users", "GET", nil) "/api/v2/users", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added newUser // Delete the added newUser
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/users/%v", newUserID), "DELETE", nil) fmt.Sprintf("/api/v2/users/%v", newUserID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Again count the number of all the users returned // Again count the number of all the users returned
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
"/api/users", "GET", nil) "/api/v2/users", "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, finalNumber, initialNumber-1) assert.Equal(t, finalNumber, initialNumber-1)

96
routes/widget/widget_test.go
View file

@ -92,7 +92,7 @@ func addScenarioAndDashboard(token string) (scenarioID uint, dashboardID uint) {
StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)}, StartParameters: postgres.Jsonb{json.RawMessage(`{"parameter1" : "testValue1A", "parameter2" : "testValue2A", "parameter3" : 42}`)},
} }
_, resp, _ := helper.TestEndpoint(router, token, _, resp, _ := helper.TestEndpoint(router, token,
"/api/scenarios", "POST", helper.KeyModels{"scenario": newScenario}) "/api/v2/scenarios", "POST", helper.KeyModels{"scenario": newScenario})
// Read newScenario's ID from the response // Read newScenario's ID from the response
newScenarioID, _ := helper.GetResponseID(resp) newScenarioID, _ := helper.GetResponseID(resp)
@ -104,14 +104,14 @@ func addScenarioAndDashboard(token string) (scenarioID uint, dashboardID uint) {
ScenarioID: uint(newScenarioID), ScenarioID: uint(newScenarioID),
} }
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
"/api/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard}) "/api/v2/dashboards", "POST", helper.KeyModels{"dashboard": newDashboard})
// Read newDashboard's ID from the response // Read newDashboard's ID from the response
newDashboardID, _ := helper.GetResponseID(resp) newDashboardID, _ := helper.GetResponseID(resp)
// add the guest user to the new scenario // add the guest user to the new scenario
_, resp, _ = helper.TestEndpoint(router, token, _, resp, _ = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil) fmt.Sprintf("/api/v2/scenarios/%v/user?username=User_C", newScenarioID), "PUT", nil)
return uint(newScenarioID), uint(newDashboardID) return uint(newScenarioID), uint(newDashboardID)
} }
@ -129,7 +129,7 @@ func TestMain(m *testing.M) {
defer database.DBpool.Close() defer database.DBpool.Close()
router = gin.Default() router = gin.Default()
api := router.Group("/api") api := router.Group("/api/v2")
user.RegisterAuthenticate(api.Group("/authenticate")) user.RegisterAuthenticate(api.Group("/authenticate"))
api.Use(user.Authentication()) api.Use(user.Authentication())
@ -150,40 +150,37 @@ func TestAddWidget(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
_, dashboardID := addScenarioAndDashboard(token) _, dashboardID := addScenarioAndDashboard(token)
newWidget.DashboardID = dashboardID newWidget.DashboardID = dashboardID
// authenticate as userB who has no access to scenario // authenticate as userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST the newWidget with no access to the scenario // try to POST the newWidget with no access to the scenario
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to POST non JSON body // try to POST non JSON body
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/widgets", "POST", "This is no JSON") "/api/v2/widgets", "POST", "This is no JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// test POST widgets/ $newWidget // test POST widgets/ $newWidget
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -197,7 +194,7 @@ func TestAddWidget(t *testing.T) {
// Get the newWidget // Get the newWidget
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "GET", nil) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -212,19 +209,18 @@ func TestAddWidget(t *testing.T) {
} }
// this should NOT work and return a unprocessable entity 442 status code // this should NOT work and return a unprocessable entity 442 status code
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": malformedNewWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": malformedNewWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as userB who has no access to scenario // authenticate as userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to GET the newWidget with no access to the scenario // try to GET the newWidget with no access to the scenario
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "GET", nil) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
} }
@ -235,8 +231,7 @@ func TestUpdateWidget(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
_, dashboardID := addScenarioAndDashboard(token) _, dashboardID := addScenarioAndDashboard(token)
@ -244,7 +239,7 @@ func TestUpdateWidget(t *testing.T) {
// test POST widgets/ $newWidget // test POST widgets/ $newWidget
newWidget.DashboardID = dashboardID newWidget.DashboardID = dashboardID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -264,44 +259,41 @@ func TestUpdateWidget(t *testing.T) {
} }
// authenticate as userB who has no access to scenario // authenticate as userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT the updatedWidget with no access to the scenario // try to PUT the updatedWidget with no access to the scenario
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget}) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as guest user who has access to scenario // authenticate as guest user who has access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.GuestCredentials)
"/api/authenticate", "POST", helper.GuestCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT as guest // try to PUT as guest
// should NOT work and result in unprocessable entity // should NOT work and result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget}) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to PUT non JSON body // try to PUT non JSON body
// should result in bad request // should result in bad request
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "PUT", "This is no JSON") fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "PUT", "This is no JSON")
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 400, code, "Response body: \n%v\n", resp) assert.Equalf(t, 400, code, "Response body: \n%v\n", resp)
// test PUT // test PUT
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget}) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "PUT", helper.KeyModels{"widget": updatedWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -311,7 +303,7 @@ func TestUpdateWidget(t *testing.T) {
// Get the updatedWidget // Get the updatedWidget
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "GET", nil) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -321,7 +313,7 @@ func TestUpdateWidget(t *testing.T) {
// try to update a widget that does not exist (should return not found 404 status code) // try to update a widget that does not exist (should return not found 404 status code)
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID+1), "PUT", helper.KeyModels{"widget": updatedWidget}) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID+1), "PUT", helper.KeyModels{"widget": updatedWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 404, code, "Response body: \n%v\n", resp) assert.Equalf(t, 404, code, "Response body: \n%v\n", resp)
@ -333,8 +325,7 @@ func TestDeleteWidget(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
_, dashboardID := addScenarioAndDashboard(token) _, dashboardID := addScenarioAndDashboard(token)
@ -342,7 +333,7 @@ func TestDeleteWidget(t *testing.T) {
// test POST widgets/ $newWidget // test POST widgets/ $newWidget
newWidget.DashboardID = dashboardID newWidget.DashboardID = dashboardID
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -351,30 +342,28 @@ func TestDeleteWidget(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// authenticate as userB who has no access to scenario // authenticate as userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to DELETE the newWidget with no access to the scenario // try to DELETE the newWidget with no access to the scenario
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "DELETE", nil) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the widgets returned for dashboard // Count the number of all the widgets returned for dashboard
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/widgets?dashboardID=%v", dashboardID), "GET", nil) fmt.Sprintf("/api/v2/widgets?dashboardID=%v", dashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// Delete the added newWidget // Delete the added newWidget
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets/%v", newWidgetID), "DELETE", nil) fmt.Sprintf("/api/v2/widgets/%v", newWidgetID), "DELETE", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -384,7 +373,7 @@ func TestDeleteWidget(t *testing.T) {
// Again count the number of all the widgets returned for dashboard // Again count the number of all the widgets returned for dashboard
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/widgets?dashboardID=%v", dashboardID), "GET", nil) fmt.Sprintf("/api/v2/widgets?dashboardID=%v", dashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber-1, finalNumber) assert.Equal(t, initialNumber-1, finalNumber)
@ -396,38 +385,35 @@ func TestGetAllWidgetsOfDashboard(t *testing.T) {
assert.NoError(t, helper.AddTestUsers()) assert.NoError(t, helper.AddTestUsers())
// authenticate as normal user // authenticate as normal user
token, err := helper.AuthenticateForTest(router, token, err := helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
_, dashboardID := addScenarioAndDashboard(token) _, dashboardID := addScenarioAndDashboard(token)
// authenticate as userB who has no access to scenario // authenticate as userB who has no access to scenario
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserBCredentials)
"/api/authenticate", "POST", helper.UserBCredentials)
assert.NoError(t, err) assert.NoError(t, err)
// try to GET all widgets of dashboard // try to GET all widgets of dashboard
// should result in unprocessable entity // should result in unprocessable entity
code, resp, err := helper.TestEndpoint(router, token, code, resp, err := helper.TestEndpoint(router, token,
fmt.Sprintf("/api/widgets?dashboardID=%v", dashboardID), "GET", nil) fmt.Sprintf("/api/v2/widgets?dashboardID=%v", dashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 422, code, "Response body: \n%v\n", resp) assert.Equalf(t, 422, code, "Response body: \n%v\n", resp)
// authenticate as normal user // authenticate as normal user
token, err = helper.AuthenticateForTest(router, token, err = helper.AuthenticateForTest(router, helper.UserACredentials)
"/api/authenticate", "POST", helper.UserACredentials)
assert.NoError(t, err) assert.NoError(t, err)
// Count the number of all the widgets returned for dashboard // Count the number of all the widgets returned for dashboard
initialNumber, err := helper.LengthOfResponse(router, token, initialNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/widgets?dashboardID=%v", dashboardID), "GET", nil) fmt.Sprintf("/api/v2/widgets?dashboardID=%v", dashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
// test POST widgets/ $newWidget // test POST widgets/ $newWidget
newWidget.DashboardID = dashboardID newWidget.DashboardID = dashboardID
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidget}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidget})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
@ -447,13 +433,13 @@ func TestGetAllWidgetsOfDashboard(t *testing.T) {
SignalIDs: []int64{}, SignalIDs: []int64{},
} }
code, resp, err = helper.TestEndpoint(router, token, code, resp, err = helper.TestEndpoint(router, token,
"/api/widgets", "POST", helper.KeyModels{"widget": newWidgetB}) "/api/v2/widgets", "POST", helper.KeyModels{"widget": newWidgetB})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equalf(t, 200, code, "Response body: \n%v\n", resp) assert.Equalf(t, 200, code, "Response body: \n%v\n", resp)
// Again count the number of all the widgets returned for dashboard // Again count the number of all the widgets returned for dashboard
finalNumber, err := helper.LengthOfResponse(router, token, finalNumber, err := helper.LengthOfResponse(router, token,
fmt.Sprintf("/api/widgets?dashboardID=%v", dashboardID), "GET", nil) fmt.Sprintf("/api/v2/widgets?dashboardID=%v", dashboardID), "GET", nil)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, initialNumber+2, finalNumber) assert.Equal(t, initialNumber+2, finalNumber)

4
start.go
View file

@ -82,7 +82,7 @@ func addData(router *gin.Engine, cfg *config.Config) error {
func main() { func main() {
log.Println("Starting VILLASweb-backend-go") log.Println("Starting VILLASweb-backend-go")
mode, _, basePath, port, amqphost, amqpuser, amqppass, err := configuration.ConfigureBackend() mode, port, amqphost, amqpuser, amqppass, err := configuration.ConfigureBackend()
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -100,7 +100,7 @@ func main() {
gin.SetMode(gin.ReleaseMode) gin.SetMode(gin.ReleaseMode)
} }
r := gin.Default() r := gin.Default()
api := r.Group(basePath) api := r.Group("/api/v2")
routes.RegisterEndpoints(r, api) routes.RegisterEndpoints(r, api)
//Start AMQP client //Start AMQP client