bitbucket.org/Aishee/synsec@v0.0.0-20210414005726-236fc01a153d/pkg/apiserver/alerts_test.go (about)

     1  package apiserver
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"strings"
    10  	"testing"
    11  	"time"
    12  
    13  	"bitbucket.org/Aishee/synsec/pkg/models"
    14  	"github.com/gin-gonic/gin"
    15  
    16  	log "github.com/sirupsen/logrus"
    17  	"github.com/stretchr/testify/assert"
    18  )
    19  
    20  func InitMachineTest() (*gin.Engine, models.WatcherAuthResponse, error) {
    21  	router, err := NewAPITest()
    22  	if err != nil {
    23  		return nil, models.WatcherAuthResponse{}, fmt.Errorf("unable to run local API: %s", err)
    24  	}
    25  
    26  	body, err := CreateTestMachine(router)
    27  	if err != nil {
    28  		return nil, models.WatcherAuthResponse{}, fmt.Errorf("%s", err.Error())
    29  	}
    30  
    31  	err = ValidateMachine("test")
    32  	if err != nil {
    33  		log.Fatalln(err.Error())
    34  	}
    35  
    36  	w := httptest.NewRecorder()
    37  	req, _ := http.NewRequest("POST", "/v1/watchers/login", strings.NewReader(body))
    38  	req.Header.Add("User-Agent", UserAgent)
    39  	router.ServeHTTP(w, req)
    40  
    41  	loginResp := models.WatcherAuthResponse{}
    42  	err = json.NewDecoder(w.Body).Decode(&loginResp)
    43  	if err != nil {
    44  		log.Fatalln(err.Error())
    45  	}
    46  
    47  	return router, loginResp, nil
    48  }
    49  
    50  func TestSimulatedAlert(t *testing.T) {
    51  	router, loginResp, err := InitMachineTest()
    52  	if err != nil {
    53  		log.Fatalln(err.Error())
    54  	}
    55  
    56  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_minibulk+simul.json")
    57  	if err != nil {
    58  		log.Fatal(err)
    59  	}
    60  	alertContent := string(alertContentBytes)
    61  
    62  	w := httptest.NewRecorder()
    63  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
    64  	req.Header.Add("User-Agent", UserAgent)
    65  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
    66  	router.ServeHTTP(w, req)
    67  
    68  	//exclude decision in simulation mode
    69  	w = httptest.NewRecorder()
    70  	req, _ = http.NewRequest("GET", "/v1/alerts?simulated=false", strings.NewReader(alertContent))
    71  	req.Header.Add("User-Agent", UserAgent)
    72  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
    73  	router.ServeHTTP(w, req)
    74  	assert.Equal(t, 200, w.Code)
    75  	assert.Contains(t, w.Body.String(), `"message":"Ip 91.121.79.178 performed breakteam/ssh-bf (6 events over `)
    76  	assert.NotContains(t, w.Body.String(), `"message":"Ip 91.121.79.179 performed breakteam/ssh-bf (6 events over `)
    77  	//include decision in simulation mode
    78  	w = httptest.NewRecorder()
    79  	req, _ = http.NewRequest("GET", "/v1/alerts?simulated=true", strings.NewReader(alertContent))
    80  	req.Header.Add("User-Agent", UserAgent)
    81  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
    82  	router.ServeHTTP(w, req)
    83  	assert.Equal(t, 200, w.Code)
    84  	assert.Contains(t, w.Body.String(), `"message":"Ip 91.121.79.178 performed breakteam/ssh-bf (6 events over `)
    85  	assert.Contains(t, w.Body.String(), `"message":"Ip 91.121.79.179 performed breakteam/ssh-bf (6 events over `)
    86  }
    87  
    88  func TestCreateAlert(t *testing.T) {
    89  	router, loginResp, err := InitMachineTest()
    90  	if err != nil {
    91  		log.Fatalln(err.Error())
    92  	}
    93  
    94  	// Create Alert with invalid format
    95  	w := httptest.NewRecorder()
    96  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader("test"))
    97  	req.Header.Add("User-Agent", UserAgent)
    98  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
    99  	router.ServeHTTP(w, req)
   100  
   101  	assert.Equal(t, 400, w.Code)
   102  	assert.Equal(t, "{\"message\":\"invalid character 'e' in literal true (expecting 'r')\"}", w.Body.String())
   103  
   104  	// Create Alert with invalid input
   105  	alertContentBytes, err := ioutil.ReadFile("./tests/invalidAlert_sample.json")
   106  	if err != nil {
   107  		log.Fatal(err)
   108  	}
   109  	alertContent := string(alertContentBytes)
   110  
   111  	w = httptest.NewRecorder()
   112  	req, _ = http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   113  	req.Header.Add("User-Agent", UserAgent)
   114  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   115  	router.ServeHTTP(w, req)
   116  
   117  	assert.Equal(t, 500, w.Code)
   118  	assert.Equal(t, "{\"message\":\"validation failure list:\\nscenario in body is required\\nscenario_hash in body is required\\nscenario_version in body is required\\nsimulated in body is required\\nsource in body is required\"}", w.Body.String())
   119  
   120  	// Create Valid Alert
   121  	alertContentBytes, err = ioutil.ReadFile("./tests/alert_sample.json")
   122  	if err != nil {
   123  		log.Fatal(err)
   124  	}
   125  	alertContent = string(alertContentBytes)
   126  
   127  	w = httptest.NewRecorder()
   128  	req, _ = http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   129  	req.Header.Add("User-Agent", UserAgent)
   130  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   131  	router.ServeHTTP(w, req)
   132  
   133  	assert.Equal(t, 201, w.Code)
   134  	assert.Equal(t, "[\"1\"]", w.Body.String())
   135  }
   136  
   137  func TestAlertListFilters(t *testing.T) {
   138  	router, loginResp, err := InitMachineTest()
   139  	if err != nil {
   140  		log.Fatalln(err.Error())
   141  	}
   142  
   143  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_ssh-bf.json")
   144  	if err != nil {
   145  		log.Fatal(err)
   146  	}
   147  
   148  	alerts := make([]*models.Alert, 0)
   149  	if err := json.Unmarshal(alertContentBytes, &alerts); err != nil {
   150  		log.Fatal(err)
   151  	}
   152  
   153  	for _, alert := range alerts {
   154  		*alert.StartAt = time.Now().Format(time.RFC3339)
   155  		*alert.StopAt = time.Now().Format(time.RFC3339)
   156  	}
   157  
   158  	alertContent, err := json.Marshal(alerts)
   159  	if err != nil {
   160  		log.Fatal(err)
   161  	}
   162  
   163  	//create one alert
   164  	w := httptest.NewRecorder()
   165  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(string(alertContent)))
   166  	req.Header.Add("User-Agent", UserAgent)
   167  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   168  	router.ServeHTTP(w, req)
   169  
   170  	//bad filter
   171  	w = httptest.NewRecorder()
   172  	req, _ = http.NewRequest("GET", "/v1/alerts?test=test", strings.NewReader(string(alertContent)))
   173  	req.Header.Add("User-Agent", UserAgent)
   174  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   175  	router.ServeHTTP(w, req)
   176  	assert.Equal(t, 500, w.Code)
   177  	assert.Equal(t, "{\"message\":\"Filter parameter 'test' is unknown (=test): invalid filter\"}", w.Body.String())
   178  
   179  	//get without filters
   180  	w = httptest.NewRecorder()
   181  	req, _ = http.NewRequest("GET", "/v1/alerts", nil)
   182  	req.Header.Add("User-Agent", UserAgent)
   183  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   184  	router.ServeHTTP(w, req)
   185  	assert.Equal(t, 200, w.Code)
   186  	//check alert and decision
   187  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   188  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   189  
   190  	//test decision_type filter (ok)
   191  	w = httptest.NewRecorder()
   192  	req, _ = http.NewRequest("GET", "/v1/alerts?decision_type=ban", nil)
   193  	req.Header.Add("User-Agent", UserAgent)
   194  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   195  	router.ServeHTTP(w, req)
   196  	assert.Equal(t, 200, w.Code)
   197  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   198  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   199  
   200  	//test decision_type filter (bad value)
   201  	w = httptest.NewRecorder()
   202  	req, _ = http.NewRequest("GET", "/v1/alerts?decision_type=ratata", nil)
   203  	req.Header.Add("User-Agent", UserAgent)
   204  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   205  	router.ServeHTTP(w, req)
   206  	assert.Equal(t, 200, w.Code)
   207  	assert.Equal(t, "null", w.Body.String())
   208  
   209  	//test scope (ok)
   210  	w = httptest.NewRecorder()
   211  	req, _ = http.NewRequest("GET", "/v1/alerts?scope=Ip", nil)
   212  	req.Header.Add("User-Agent", UserAgent)
   213  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   214  	router.ServeHTTP(w, req)
   215  	assert.Equal(t, 200, w.Code)
   216  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   217  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   218  
   219  	//test scope (bad value)
   220  	w = httptest.NewRecorder()
   221  	req, _ = http.NewRequest("GET", "/v1/alerts?scope=rarara", nil)
   222  	req.Header.Add("User-Agent", UserAgent)
   223  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   224  	router.ServeHTTP(w, req)
   225  	assert.Equal(t, 200, w.Code)
   226  	assert.Equal(t, "null", w.Body.String())
   227  
   228  	//test scenario (ok)
   229  	w = httptest.NewRecorder()
   230  	req, _ = http.NewRequest("GET", "/v1/alerts?scenario=breakteam/ssh-bf", nil)
   231  	req.Header.Add("User-Agent", UserAgent)
   232  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   233  	router.ServeHTTP(w, req)
   234  	assert.Equal(t, 200, w.Code)
   235  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   236  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   237  
   238  	//test scenario (bad value)
   239  	w = httptest.NewRecorder()
   240  	req, _ = http.NewRequest("GET", "/v1/alerts?scenario=breakteam/nope", nil)
   241  	req.Header.Add("User-Agent", UserAgent)
   242  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   243  	router.ServeHTTP(w, req)
   244  	assert.Equal(t, 200, w.Code)
   245  	assert.Equal(t, "null", w.Body.String())
   246  
   247  	//test ip (ok)
   248  	w = httptest.NewRecorder()
   249  	req, _ = http.NewRequest("GET", "/v1/alerts?ip=91.121.79.195", nil)
   250  	req.Header.Add("User-Agent", UserAgent)
   251  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   252  	router.ServeHTTP(w, req)
   253  	assert.Equal(t, 200, w.Code)
   254  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   255  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   256  
   257  	//test ip (bad value)
   258  	w = httptest.NewRecorder()
   259  	req, _ = http.NewRequest("GET", "/v1/alerts?ip=99.122.77.195", nil)
   260  	req.Header.Add("User-Agent", UserAgent)
   261  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   262  	router.ServeHTTP(w, req)
   263  	assert.Equal(t, 200, w.Code)
   264  	assert.Equal(t, "null", w.Body.String())
   265  
   266  	//test ip (invalid value)
   267  	w = httptest.NewRecorder()
   268  	req, _ = http.NewRequest("GET", "/v1/alerts?ip=gruueq", nil)
   269  	req.Header.Add("User-Agent", UserAgent)
   270  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   271  	router.ServeHTTP(w, req)
   272  	assert.Equal(t, 500, w.Code)
   273  	assert.Equal(t, `{"message":"unable to convert 'gruueq' to int: invalid address: invalid ip address / range"}`, w.Body.String())
   274  
   275  	//test range (ok)
   276  	w = httptest.NewRecorder()
   277  	req, _ = http.NewRequest("GET", "/v1/alerts?range=91.121.79.0/24&contains=false", nil)
   278  	req.Header.Add("User-Agent", UserAgent)
   279  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   280  	router.ServeHTTP(w, req)
   281  	assert.Equal(t, 200, w.Code)
   282  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   283  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   284  
   285  	//test range
   286  	w = httptest.NewRecorder()
   287  	req, _ = http.NewRequest("GET", "/v1/alerts?range=99.122.77.0/24&contains=false", nil)
   288  	req.Header.Add("User-Agent", UserAgent)
   289  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   290  	router.ServeHTTP(w, req)
   291  	assert.Equal(t, 200, w.Code)
   292  	assert.Equal(t, "null", w.Body.String())
   293  
   294  	//test range (invalid value)
   295  	w = httptest.NewRecorder()
   296  	req, _ = http.NewRequest("GET", "/v1/alerts?range=ratata", nil)
   297  	req.Header.Add("User-Agent", UserAgent)
   298  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   299  	router.ServeHTTP(w, req)
   300  	assert.Equal(t, 500, w.Code)
   301  	assert.Equal(t, `{"message":"unable to convert 'ratata' to int: invalid address: invalid ip address / range"}`, w.Body.String())
   302  
   303  	//test since (ok)
   304  	w = httptest.NewRecorder()
   305  	req, _ = http.NewRequest("GET", "/v1/alerts?since=1h", nil)
   306  	req.Header.Add("User-Agent", UserAgent)
   307  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   308  	router.ServeHTTP(w, req)
   309  	assert.Equal(t, 200, w.Code)
   310  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   311  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   312  
   313  	//test since (ok but yelds no results)
   314  	w = httptest.NewRecorder()
   315  	req, _ = http.NewRequest("GET", "/v1/alerts?since=1ns", nil)
   316  	req.Header.Add("User-Agent", UserAgent)
   317  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   318  	router.ServeHTTP(w, req)
   319  	assert.Equal(t, 200, w.Code)
   320  	assert.Equal(t, "null", w.Body.String())
   321  
   322  	//test since (invalid value)
   323  	w = httptest.NewRecorder()
   324  	req, _ = http.NewRequest("GET", "/v1/alerts?since=1zuzu", nil)
   325  	req.Header.Add("User-Agent", UserAgent)
   326  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   327  	router.ServeHTTP(w, req)
   328  	assert.Equal(t, 500, w.Code)
   329  	assert.Contains(t, w.Body.String(), `{"message":"while parsing duration: time: unknown unit`)
   330  
   331  	//test until (ok)
   332  	w = httptest.NewRecorder()
   333  	req, _ = http.NewRequest("GET", "/v1/alerts?until=1ns", nil)
   334  	req.Header.Add("User-Agent", UserAgent)
   335  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   336  	router.ServeHTTP(w, req)
   337  	assert.Equal(t, 200, w.Code)
   338  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   339  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   340  
   341  	//test until (ok but no return)
   342  	w = httptest.NewRecorder()
   343  	req, _ = http.NewRequest("GET", "/v1/alerts?until=1m", nil)
   344  	req.Header.Add("User-Agent", UserAgent)
   345  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   346  	router.ServeHTTP(w, req)
   347  	assert.Equal(t, 200, w.Code)
   348  	assert.Equal(t, "null", w.Body.String())
   349  
   350  	//test until (invalid value)
   351  	w = httptest.NewRecorder()
   352  	req, _ = http.NewRequest("GET", "/v1/alerts?until=1zuzu", nil)
   353  	req.Header.Add("User-Agent", UserAgent)
   354  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   355  	router.ServeHTTP(w, req)
   356  	assert.Equal(t, 500, w.Code)
   357  	assert.Contains(t, w.Body.String(), `{"message":"while parsing duration: time: unknown unit`)
   358  
   359  	//test simulated (ok)
   360  	w = httptest.NewRecorder()
   361  	req, _ = http.NewRequest("GET", "/v1/alerts?simulated=true", nil)
   362  	req.Header.Add("User-Agent", UserAgent)
   363  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   364  	router.ServeHTTP(w, req)
   365  	assert.Equal(t, 200, w.Code)
   366  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   367  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   368  
   369  	//test simulated (ok)
   370  	w = httptest.NewRecorder()
   371  	req, _ = http.NewRequest("GET", "/v1/alerts?simulated=false", nil)
   372  	req.Header.Add("User-Agent", UserAgent)
   373  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   374  	router.ServeHTTP(w, req)
   375  	assert.Equal(t, 200, w.Code)
   376  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   377  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   378  
   379  	//test has active decision
   380  	w = httptest.NewRecorder()
   381  	req, _ = http.NewRequest("GET", "/v1/alerts?has_active_decision=true", nil)
   382  	req.Header.Add("User-Agent", UserAgent)
   383  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   384  	router.ServeHTTP(w, req)
   385  	assert.Equal(t, 200, w.Code)
   386  	assert.Contains(t, w.Body.String(), "Ip 91.121.79.195 performed 'breakteam/ssh-bf' (6 events over ")
   387  	assert.Contains(t, w.Body.String(), `scope":"Ip","simulated":false,"type":"ban","value":"91.121.79.195"`)
   388  
   389  	//test has active decision
   390  	w = httptest.NewRecorder()
   391  	req, _ = http.NewRequest("GET", "/v1/alerts?has_active_decision=false", nil)
   392  	req.Header.Add("User-Agent", UserAgent)
   393  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   394  	router.ServeHTTP(w, req)
   395  	assert.Equal(t, 200, w.Code)
   396  	assert.Equal(t, "null", w.Body.String())
   397  
   398  	//test has active decision (invalid value)
   399  	w = httptest.NewRecorder()
   400  	req, _ = http.NewRequest("GET", "/v1/alerts?has_active_decision=ratatqata", nil)
   401  	req.Header.Add("User-Agent", UserAgent)
   402  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   403  	router.ServeHTTP(w, req)
   404  	assert.Equal(t, 500, w.Code)
   405  	assert.Equal(t, `{"message":"'ratatqata' is not a boolean: strconv.ParseBool: parsing \"ratatqata\": invalid syntax: unable to parse type"}`, w.Body.String())
   406  
   407  }
   408  
   409  func TestAlertBulkInsert(t *testing.T) {
   410  	router, loginResp, err := InitMachineTest()
   411  	if err != nil {
   412  		log.Fatalln(err.Error())
   413  	}
   414  
   415  	//insert a bulk of 20 alerts to trigger bulk insert
   416  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_bulk.json")
   417  	if err != nil {
   418  		log.Fatal(err)
   419  	}
   420  	alertContent := string(alertContentBytes)
   421  
   422  	w := httptest.NewRecorder()
   423  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   424  	req.Header.Add("User-Agent", UserAgent)
   425  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   426  	router.ServeHTTP(w, req)
   427  
   428  	w = httptest.NewRecorder()
   429  	req, _ = http.NewRequest("GET", "/v1/alerts", strings.NewReader(alertContent))
   430  	req.Header.Add("User-Agent", UserAgent)
   431  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   432  	router.ServeHTTP(w, req)
   433  	assert.Equal(t, 200, w.Code)
   434  }
   435  
   436  func TestListAlert(t *testing.T) {
   437  	router, loginResp, err := InitMachineTest()
   438  	if err != nil {
   439  		log.Fatalln(err.Error())
   440  	}
   441  
   442  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_sample.json")
   443  	if err != nil {
   444  		log.Fatal(err)
   445  	}
   446  	alertContent := string(alertContentBytes)
   447  
   448  	w := httptest.NewRecorder()
   449  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   450  	req.Header.Add("User-Agent", UserAgent)
   451  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   452  	router.ServeHTTP(w, req)
   453  
   454  	// List Alert with invalid filter
   455  	w = httptest.NewRecorder()
   456  	req, _ = http.NewRequest("GET", "/v1/alerts?test=test", nil)
   457  	req.Header.Add("User-Agent", UserAgent)
   458  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   459  	router.ServeHTTP(w, req)
   460  	assert.Equal(t, 500, w.Code)
   461  	assert.Equal(t, "{\"message\":\"Filter parameter 'test' is unknown (=test): invalid filter\"}", w.Body.String())
   462  
   463  	// List Alert
   464  	w = httptest.NewRecorder()
   465  	req, _ = http.NewRequest("GET", "/v1/alerts", nil)
   466  	req.Header.Add("User-Agent", UserAgent)
   467  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   468  	router.ServeHTTP(w, req)
   469  
   470  	assert.Equal(t, 200, w.Code)
   471  	assert.Contains(t, w.Body.String(), "breakteam/test")
   472  }
   473  
   474  func TestCreateAlertErrors(t *testing.T) {
   475  	router, loginResp, err := InitMachineTest()
   476  	if err != nil {
   477  		log.Fatalln(err.Error())
   478  	}
   479  
   480  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_sample.json")
   481  	if err != nil {
   482  		log.Fatal(err)
   483  	}
   484  	alertContent := string(alertContentBytes)
   485  
   486  	//test invalid bearer
   487  	w := httptest.NewRecorder()
   488  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   489  	req.Header.Add("User-Agent", UserAgent)
   490  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", "ratata"))
   491  	router.ServeHTTP(w, req)
   492  	assert.Equal(t, 401, w.Code)
   493  
   494  	//test invalid bearer
   495  	w = httptest.NewRecorder()
   496  	req, _ = http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   497  	req.Header.Add("User-Agent", UserAgent)
   498  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token+"s"))
   499  	router.ServeHTTP(w, req)
   500  	assert.Equal(t, 401, w.Code)
   501  
   502  }
   503  
   504  func TestDeleteAlert(t *testing.T) {
   505  	router, loginResp, err := InitMachineTest()
   506  	if err != nil {
   507  		log.Fatalln(err.Error())
   508  	}
   509  
   510  	alertContentBytes, err := ioutil.ReadFile("./tests/alert_sample.json")
   511  	if err != nil {
   512  		log.Fatal(err)
   513  	}
   514  	alertContent := string(alertContentBytes)
   515  
   516  	w := httptest.NewRecorder()
   517  	req, _ := http.NewRequest("POST", "/v1/alerts", strings.NewReader(alertContent))
   518  	req.Header.Add("User-Agent", UserAgent)
   519  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   520  	router.ServeHTTP(w, req)
   521  
   522  	// Fail Delete Alert
   523  	w = httptest.NewRecorder()
   524  	req, _ = http.NewRequest("DELETE", "/v1/alerts", strings.NewReader(""))
   525  	req.Header.Add("User-Agent", UserAgent)
   526  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   527  	req.RemoteAddr = "127.0.0.2:4242"
   528  	router.ServeHTTP(w, req)
   529  
   530  	assert.Equal(t, 403, w.Code)
   531  	assert.Equal(t, `{"message":"access forbidden from this IP (127.0.0.2)"}`, w.Body.String())
   532  
   533  	// Delete Alert
   534  	w = httptest.NewRecorder()
   535  	req, _ = http.NewRequest("DELETE", "/v1/alerts", strings.NewReader(""))
   536  	req.Header.Add("User-Agent", UserAgent)
   537  	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", loginResp.Token))
   538  	req.RemoteAddr = "127.0.0.1:4242"
   539  	router.ServeHTTP(w, req)
   540  	assert.Equal(t, 200, w.Code)
   541  	assert.Equal(t, `{"nbDeleted":"1"}`, w.Body.String())
   542  }