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

     1  package apiserver
     2  
     3  import (
     4  	"encoding/json"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"strings"
     8  	"testing"
     9  
    10  	log "github.com/sirupsen/logrus"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestCreateMachine(t *testing.T) {
    15  	router, err := NewAPITest()
    16  	if err != nil {
    17  		log.Fatalf("unable to run local API: %s", err)
    18  	}
    19  
    20  	// Create machine with invalid format
    21  	w := httptest.NewRecorder()
    22  	req, _ := http.NewRequest("POST", "/v1/watchers", strings.NewReader("test"))
    23  	req.Header.Add("User-Agent", UserAgent)
    24  	router.ServeHTTP(w, req)
    25  
    26  	assert.Equal(t, 400, w.Code)
    27  	assert.Equal(t, "{\"message\":\"invalid character 'e' in literal true (expecting 'r')\"}", w.Body.String())
    28  
    29  	// Create machine with invalid input
    30  	w = httptest.NewRecorder()
    31  	req, _ = http.NewRequest("POST", "/v1/watchers", strings.NewReader("{\"test\": \"test\"}"))
    32  	req.Header.Add("User-Agent", UserAgent)
    33  	router.ServeHTTP(w, req)
    34  
    35  	assert.Equal(t, 500, w.Code)
    36  	assert.Equal(t, "{\"message\":\"validation failure list:\\nmachine_id in body is required\\npassword in body is required\"}", w.Body.String())
    37  
    38  	// Create machine
    39  	b, err := json.Marshal(MachineTest)
    40  	if err != nil {
    41  		log.Fatalf("unable to marshal MachineTest")
    42  	}
    43  	body := string(b)
    44  
    45  	w = httptest.NewRecorder()
    46  	req, _ = http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
    47  	req.Header.Add("User-Agent", UserAgent)
    48  	router.ServeHTTP(w, req)
    49  
    50  	assert.Equal(t, 201, w.Code)
    51  	assert.Equal(t, "", w.Body.String())
    52  
    53  }
    54  
    55  func TestCreateMachineWithForwardedFor(t *testing.T) {
    56  	router, err := NewAPITestForwardedFor()
    57  	if err != nil {
    58  		log.Fatalf("unable to run local API: %s", err)
    59  	}
    60  
    61  	// Create machine
    62  	b, err := json.Marshal(MachineTest)
    63  	if err != nil {
    64  		log.Fatalf("unable to marshal MachineTest")
    65  	}
    66  	body := string(b)
    67  
    68  	w := httptest.NewRecorder()
    69  	req, _ := http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
    70  	req.Header.Add("User-Agent", UserAgent)
    71  	req.Header.Add("X-Real-IP", "1.1.1.1")
    72  	router.ServeHTTP(w, req)
    73  
    74  	assert.Equal(t, 201, w.Code)
    75  	assert.Equal(t, "", w.Body.String())
    76  
    77  	ip, err := GetMachineIP(*MachineTest.MachineID)
    78  	if err != nil {
    79  		log.Fatalf("Could not get machine IP : %s", err)
    80  	}
    81  	assert.Equal(t, "1.1.1.1", ip)
    82  }
    83  
    84  func TestCreateMachineWithForwardedForNoConfig(t *testing.T) {
    85  	router, err := NewAPITest()
    86  	if err != nil {
    87  		log.Fatalf("unable to run local API: %s", err)
    88  	}
    89  
    90  	// Create machine
    91  	b, err := json.Marshal(MachineTest)
    92  	if err != nil {
    93  		log.Fatalf("unable to marshal MachineTest")
    94  	}
    95  	body := string(b)
    96  
    97  	w := httptest.NewRecorder()
    98  	req, _ := http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
    99  	req.Header.Add("User-Agent", UserAgent)
   100  	req.Header.Add("X-Real-IP", "1.1.1.1")
   101  	router.ServeHTTP(w, req)
   102  
   103  	assert.Equal(t, 201, w.Code)
   104  	assert.Equal(t, "", w.Body.String())
   105  
   106  	ip, err := GetMachineIP(*MachineTest.MachineID)
   107  	if err != nil {
   108  		log.Fatalf("Could not get machine IP : %s", err)
   109  	}
   110  	//For some reason, the IP is empty when running tests
   111  	//if no forwarded-for headers are present
   112  	assert.Equal(t, "", ip)
   113  }
   114  
   115  func TestCreateMachineWithoutForwardedFor(t *testing.T) {
   116  	router, err := NewAPITestForwardedFor()
   117  	if err != nil {
   118  		log.Fatalf("unable to run local API: %s", err)
   119  	}
   120  
   121  	// Create machine
   122  	b, err := json.Marshal(MachineTest)
   123  	if err != nil {
   124  		log.Fatalf("unable to marshal MachineTest")
   125  	}
   126  	body := string(b)
   127  
   128  	w := httptest.NewRecorder()
   129  	req, _ := http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
   130  	req.Header.Add("User-Agent", UserAgent)
   131  	router.ServeHTTP(w, req)
   132  
   133  	assert.Equal(t, 201, w.Code)
   134  	assert.Equal(t, "", w.Body.String())
   135  
   136  	ip, err := GetMachineIP(*MachineTest.MachineID)
   137  	if err != nil {
   138  		log.Fatalf("Could not get machine IP : %s", err)
   139  	}
   140  	//For some reason, the IP is empty when running tests
   141  	//if no forwarded-for headers are present
   142  	assert.Equal(t, "", ip)
   143  }
   144  
   145  func TestCreateMachineAlreadyExist(t *testing.T) {
   146  	router, err := NewAPITest()
   147  	if err != nil {
   148  		log.Fatalf("unable to run local API: %s", err)
   149  	}
   150  
   151  	body, err := CreateTestMachine(router)
   152  	if err != nil {
   153  		log.Fatalln(err.Error())
   154  	}
   155  
   156  	w := httptest.NewRecorder()
   157  	req, _ := http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
   158  	req.Header.Add("User-Agent", UserAgent)
   159  	router.ServeHTTP(w, req)
   160  
   161  	w = httptest.NewRecorder()
   162  	req, _ = http.NewRequest("POST", "/v1/watchers", strings.NewReader(body))
   163  	req.Header.Add("User-Agent", UserAgent)
   164  	router.ServeHTTP(w, req)
   165  
   166  	assert.Equal(t, 403, w.Code)
   167  	assert.Equal(t, "{\"message\":\"user 'test': user already exist\"}", w.Body.String())
   168  
   169  }