github.com/justinjmoses/evergreen@v0.0.0-20170530173719-1d50e381ff0d/rest/route/prefetch_test.go (about)

     1  package route
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  	"testing"
     7  
     8  	"github.com/evergreen-ci/evergreen"
     9  	"github.com/evergreen-ci/evergreen/model"
    10  	"github.com/evergreen-ci/evergreen/model/patch"
    11  	"github.com/evergreen-ci/evergreen/model/user"
    12  	"github.com/evergreen-ci/evergreen/rest"
    13  	"github.com/evergreen-ci/evergreen/rest/data"
    14  	"github.com/gorilla/context"
    15  	. "github.com/smartystreets/goconvey/convey"
    16  )
    17  
    18  func TestPrefetchUser(t *testing.T) {
    19  	Convey("When there are users to fetch and a request", t, func() {
    20  		serviceContext := &data.MockConnector{}
    21  		users := map[string]*user.DBUser{}
    22  		numUsers := 10
    23  		for i := 0; i < numUsers; i++ {
    24  			userId := fmt.Sprintf("user_%d", i)
    25  			apiKey := fmt.Sprintf("apiKey_%d", i)
    26  			users[userId] = &user.DBUser{
    27  				Id:     userId,
    28  				APIKey: apiKey,
    29  			}
    30  		}
    31  		serviceContext.MockUserConnector.CachedUsers = users
    32  		req, err := http.NewRequest(evergreen.MethodGet, "/", nil)
    33  		So(err, ShouldBeNil)
    34  		Convey("When examining users", func() {
    35  
    36  			Reset(func() {
    37  				context.Clear(req)
    38  			})
    39  
    40  			Convey("When no header is set, should no-op", func() {
    41  				err := PrefetchUser(req, serviceContext)
    42  				So(err, ShouldBeNil)
    43  
    44  				So(context.Get(req, RequestUser), ShouldBeNil)
    45  			})
    46  
    47  			Convey("When just API-Key is set, should not set anything", func() {
    48  				for i := 0; i < numUsers; i++ {
    49  					req.Header = http.Header{}
    50  					userId := fmt.Sprintf("user_%d", i)
    51  					req.Header.Set("Api-User", userId)
    52  					err := PrefetchUser(req, serviceContext)
    53  					So(err, ShouldBeNil)
    54  
    55  					So(context.Get(req, RequestUser), ShouldBeNil)
    56  				}
    57  			})
    58  			Convey("When API-User and API-Key is set,"+
    59  				" should set user in the context", func() {
    60  				for i := 0; i < numUsers; i++ {
    61  					req.Header = http.Header{}
    62  					userId := fmt.Sprintf("user_%d", i)
    63  					apiKey := fmt.Sprintf("apiKey_%d", i)
    64  					req.Header.Set("Api-Key", apiKey)
    65  					req.Header.Set("Api-User", userId)
    66  					err := PrefetchUser(req, serviceContext)
    67  					So(err, ShouldBeNil)
    68  					u := user.DBUser{
    69  						Id:     userId,
    70  						APIKey: apiKey,
    71  					}
    72  
    73  					So(context.Get(req, RequestUser), ShouldResemble, &u)
    74  				}
    75  			})
    76  			Convey("When API-User and API-Key is set incorrectly,"+
    77  				" should return an error", func() {
    78  				for i := 0; i < numUsers; i++ {
    79  					req.Header = http.Header{}
    80  					userId := fmt.Sprintf("user_%d", i)
    81  					apiKey := fmt.Sprintf("apiKey_%d", i+1)
    82  					req.Header.Set("Api-Key", apiKey)
    83  					req.Header.Set("Api-User", userId)
    84  
    85  					err := PrefetchUser(req, serviceContext)
    86  
    87  					errToResemble := rest.APIError{
    88  						StatusCode: http.StatusUnauthorized,
    89  						Message:    "Invalid API key",
    90  					}
    91  
    92  					So(err, ShouldResemble, errToResemble)
    93  					So(context.Get(req, RequestUser), ShouldBeNil)
    94  				}
    95  			})
    96  		})
    97  	})
    98  }
    99  
   100  func TestPrefetchProject(t *testing.T) {
   101  	Convey("When there is a data and a request", t, func() {
   102  		serviceContext := &data.MockConnector{}
   103  		req, err := http.NewRequest(evergreen.MethodGet, "/", nil)
   104  		So(err, ShouldBeNil)
   105  		Convey("When fetching the project context", func() {
   106  			Reset(func() {
   107  				context.Clear(req)
   108  			})
   109  			Convey("should error if project is private and no user is set", func() {
   110  				ctx := model.Context{}
   111  				ctx.ProjectRef = &model.ProjectRef{
   112  					Private: true,
   113  				}
   114  				serviceContext.MockContextConnector.CachedContext = ctx
   115  				err := PrefetchProjectContext(req, serviceContext)
   116  				So(context.Get(req, RequestContext), ShouldBeNil)
   117  
   118  				errToResemble := rest.APIError{
   119  					StatusCode: http.StatusNotFound,
   120  					Message:    "Project not found",
   121  				}
   122  				So(err, ShouldResemble, errToResemble)
   123  			})
   124  			Convey("should error if patch exists and no user is set", func() {
   125  				ctx := model.Context{}
   126  				ctx.Patch = &patch.Patch{}
   127  				serviceContext.MockContextConnector.CachedContext = ctx
   128  				err := PrefetchProjectContext(req, serviceContext)
   129  				So(context.Get(req, RequestContext), ShouldBeNil)
   130  
   131  				errToResemble := rest.APIError{
   132  					StatusCode: http.StatusNotFound,
   133  					Message:    "Not found",
   134  				}
   135  				So(err, ShouldResemble, errToResemble)
   136  			})
   137  			Convey("should succeed if project ref exists and user is set", func() {
   138  				ctx := model.Context{}
   139  				ctx.ProjectRef = &model.ProjectRef{
   140  					Private: true,
   141  				}
   142  				context.Set(req, RequestUser, &user.DBUser{Id: "test_user"})
   143  				serviceContext.MockContextConnector.CachedContext = ctx
   144  				err := PrefetchProjectContext(req, serviceContext)
   145  				So(err, ShouldBeNil)
   146  
   147  				So(context.Get(req, RequestContext), ShouldResemble, &ctx)
   148  			})
   149  		})
   150  	})
   151  }