github.com/covergates/covergates@v0.2.2-0.20201009050117-42ef8a19fb95/routers/api/repo/repo_test.go (about)

     1  package repo
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"reflect"
    10  	"testing"
    11  
    12  	"github.com/covergates/covergates/core"
    13  	"github.com/covergates/covergates/mock"
    14  	"github.com/covergates/covergates/routers/api/request"
    15  	"github.com/gin-gonic/gin"
    16  	"github.com/golang/mock/gomock"
    17  )
    18  
    19  func testRequest(r *gin.Engine, req *http.Request, f func(*httptest.ResponseRecorder)) {
    20  	w := httptest.NewRecorder()
    21  	r.ServeHTTP(w, req)
    22  	f(w)
    23  }
    24  
    25  func TestCreate(t *testing.T) {
    26  	ctrl := gomock.NewController(t)
    27  	defer ctrl.Finish()
    28  	repo := &core.Repo{
    29  		URL:       "http://gitea/org/repo",
    30  		NameSpace: "org",
    31  		Name:      "repo",
    32  		SCM:       core.Gitea,
    33  		Branch:    "master",
    34  	}
    35  	user := &core.User{}
    36  	store := mock.NewMockRepoStore(ctrl)
    37  	store.EXPECT().Create(gomock.Eq(repo)).Return(nil)
    38  	service := mock.NewMockSCMService(ctrl)
    39  
    40  	data, err := json.Marshal(repo)
    41  	if err != nil {
    42  		t.Error(err)
    43  		return
    44  	}
    45  	read := bytes.NewReader(data)
    46  	req, _ := http.NewRequest("POST", "/repo", read)
    47  	r := gin.Default()
    48  	r.Use(func(c *gin.Context) {
    49  		request.WithUser(c, user)
    50  	})
    51  	r.POST("/repo", HandleCreate(store, service))
    52  	testRequest(r, req, func(w *httptest.ResponseRecorder) {
    53  		rst := w.Result()
    54  		if rst.StatusCode != 200 {
    55  			t.Fail()
    56  			return
    57  		}
    58  		data, err := ioutil.ReadAll(rst.Body)
    59  		if err != nil {
    60  			t.Error(err)
    61  			return
    62  		}
    63  		rstRepo := &core.Repo{}
    64  		json.Unmarshal(data, rstRepo)
    65  		if !reflect.DeepEqual(repo, rstRepo) {
    66  			t.Fail()
    67  		}
    68  	})
    69  }
    70  
    71  func TestListSCM(t *testing.T) {
    72  	ctrl := gomock.NewController(t)
    73  	defer ctrl.Finish()
    74  
    75  	user := &core.User{}
    76  	scmRepos := []*core.Repo{
    77  		{
    78  			Name: "repo1",
    79  			URL:  "url1",
    80  		},
    81  		{
    82  			Name: "repo2",
    83  			URL:  "url2",
    84  		},
    85  	}
    86  	storeRepos := []*core.Repo{
    87  		{
    88  			URL:      "url2",
    89  			ReportID: "report_id",
    90  		},
    91  	}
    92  	urls := make([]string, len(scmRepos))
    93  	for i, repo := range scmRepos {
    94  		urls[i] = repo.URL
    95  	}
    96  
    97  	mockService := mock.NewMockSCMService(ctrl)
    98  	mockClient := mock.NewMockClient(ctrl)
    99  	mockRepoService := mock.NewMockGitRepoService(ctrl)
   100  	mockStore := mock.NewMockRepoStore(ctrl)
   101  
   102  	mockService.EXPECT().Client(gomock.Eq(core.Github)).Return(mockClient, nil)
   103  	mockClient.EXPECT().Repositories().Return(mockRepoService)
   104  	mockRepoService.EXPECT().List(gomock.Any(), gomock.Eq(user)).Return(scmRepos, nil)
   105  	mockStore.EXPECT().Finds(gomock.Eq(urls)).Return(storeRepos, nil)
   106  
   107  	r := gin.Default()
   108  	r.Use(func(c *gin.Context) {
   109  		request.WithUser(c, user)
   110  	})
   111  	r.GET("/repos/:scm", HandleListSCM(mockService, mockStore))
   112  
   113  	req, _ := http.NewRequest("GET", "/repos/github", nil)
   114  	testRequest(r, req, func(w *httptest.ResponseRecorder) {
   115  		rst := w.Result()
   116  		if rst.StatusCode != 200 {
   117  			t.Fail()
   118  			return
   119  		}
   120  		data, _ := ioutil.ReadAll(rst.Body)
   121  		var repos []*core.Repo
   122  		json.Unmarshal(data, &repos)
   123  		if len(repos) < 2 {
   124  			t.Fail()
   125  			return
   126  		}
   127  		if repos[0].ReportID != "" {
   128  			t.Fail()
   129  		}
   130  		if repos[1].ReportID != "report_id" {
   131  			t.Fail()
   132  		}
   133  	})
   134  }
   135  
   136  func TestReportIDRenew(t *testing.T) {
   137  	ctrl := gomock.NewController(t)
   138  	defer ctrl.Finish()
   139  
   140  	// data
   141  	user := &core.User{}
   142  
   143  	repo := &core.Repo{
   144  		Name:      "repo",
   145  		NameSpace: "github",
   146  		SCM:       core.Github,
   147  	}
   148  
   149  	// mock
   150  	mockStore := mock.NewMockRepoStore(ctrl)
   151  	mockStore.EXPECT().Find(gomock.Eq(repo)).Return(repo, nil)
   152  	mockStore.EXPECT().Update(gomock.Eq(&core.Repo{
   153  		Name:      repo.Name,
   154  		NameSpace: repo.NameSpace,
   155  		SCM:       repo.SCM,
   156  		ReportID:  "123",
   157  	})).Return(nil)
   158  	mockStore.EXPECT().UpdateCreator(gomock.Any(), gomock.Eq(user)).Return(nil)
   159  	mockService := mock.NewMockSCMService(ctrl)
   160  	mockClient := mock.NewMockClient(ctrl)
   161  	mockRepositories := mock.NewMockGitRepoService(ctrl)
   162  	mockService.EXPECT().Client(gomock.Eq(core.Github)).Return(mockClient, nil)
   163  	mockClient.EXPECT().Repositories().Return(mockRepositories)
   164  	mockRepositories.EXPECT().NewReportID(gomock.Eq(repo)).Return("123")
   165  
   166  	r := gin.Default()
   167  	r.Use(func(c *gin.Context) {
   168  		request.WithUser(c, user)
   169  	})
   170  	r.PATCH("/repos/:scm/:namespace/:name/report", HandleReportIDRenew(mockStore, mockService))
   171  
   172  	req, _ := http.NewRequest("PATCH", "/repos/github/github/repo/report", nil)
   173  	testRequest(r, req, func(h *httptest.ResponseRecorder) {
   174  		result := h.Result()
   175  		if result.StatusCode != 200 {
   176  			t.Fatal()
   177  		}
   178  	})
   179  }