func TestWithReview(t *testing.T) {
is := is.New(t)
freelancerRepositoryMock := &FreelancerRepositoryMock{}
var freelancerContext = &ApplicationContext{
FreelancerRepository: freelancerRepositoryMock,
}
w := httptest.NewRecorder()
r := getRequest(freelancerContext, `
{
"title": "title",
"clientID": 2,
"content": "content",
"freelancerID": 3,
"jobID": 4,
"rating": 5.6
}`)
next := func(review *Review) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
is.Equal(review.Title, "title")
is.Equal(review.ClientID, 2)
is.Equal(review.Content, "content")
is.Equal(review.FreelancerID, 3)
is.Equal(review.JobID, 4)
is.Equal(review.Rating, 5.6)
})
}
withReview{next}.ServeHTTP(w, r)
}
func TestIndexProject(t *testing.T) {
is := is.New(t)
projectRepositoryMock := &ProjectRepositoryMock{}
projectRepositoryMock.GetAllProjectsCall.Returns.Projects = []Project{
Project{
Model: Model{
ID: 1,
},
},
Project{
Model: Model{
ID: 2,
},
},
}
userContext := &ApplicationContext{
ProjectRepository: projectRepositoryMock,
}
r := getRequest(userContext, ``)
w := httptest.NewRecorder()
IndexProject(w, r)
is.Equal(w.Code, http.StatusOK)
var body []Project
is.NoErr(json.Unmarshal(w.Body.Bytes(), &body))
is.Equal(body[0].Model.ID, 1)
is.Equal(body[1].Model.ID, 2)
}
func TestValueEqual(t *testing.T) {
is := is.New(t)
v := ParseValue([]byte("something"))
is.True(v.Equal("something"))
is.False(v.Equal("else"))
is.Equal("string", v.Type())
v = ParseValue([]byte("123"))
is.Equal("float64", v.Type())
v = ParseValue([]byte("/^2.{2}$/"))
is.True(v.Equal(200))
is.True(v.Equal(201))
is.False(v.Equal(404))
is.Equal("regex", v.Type())
v = ParseValue([]byte("/application/json/"))
is.True(v.Equal("application/json"))
is.True(v.Equal("application/json; charset=utf-8"))
is.True(v.Equal("text/xml; application/json; charset=utf-8"))
is.False(v.Equal("text/xml; charset=utf-8"))
is.Equal("regex", v.Type())
is.Equal(`/application/json/`, v.String())
v = ParseValue([]byte("/Silk/"))
is.True(v.Equal("My name is Silk."))
is.True(v.Equal("Silk is my name."))
is.False(v.Equal("I don't contain that word!"))
}
func TestWithError(t *testing.T) {
is := is.New(t)
w := httptest.NewRecorder()
r := newTestRequest()
err := errors.New("something went wrong")
opts := &respond.Options{
Before: func(w http.ResponseWriter, r *http.Request, status int, data interface{}) (int, interface{}) {
if err, ok := data.(error); ok {
return status, map[string]interface{}{"error": err.Error()}
}
return status, data
},
}
testHandler := &testHandler{
status: http.StatusInternalServerError,
data: err,
}
handler := opts.Handler(testHandler)
handler.ServeHTTP(w, r)
is.Equal(http.StatusInternalServerError, w.Code)
var data map[string]interface{}
is.NoErr(json.Unmarshal(w.Body.Bytes(), &data))
is.Equal(data, map[string]interface{}{"error": err.Error()})
is.Equal(w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
}
func TestFileList(t *testing.T) {
is := is.New(t)
s := NewShell(shellUrl)
list, err := s.FileList(fmt.Sprintf("/ipfs/%s", examplesHash))
is.Nil(err)
is.Equal(list.Type, "Directory")
is.Equal(list.Size, 0)
is.Equal(len(list.Links), 6)
// TODO: document difference in sice betwen 'ipfs ls' and 'ipfs file ls -v'. additional object encoding in data block?
expected := map[string]UnixLsLink{
"about": {Type: "File", Hash: "QmZTR5bcpQD7cFgTorqxZDYaew1Wqgfbd2ud9QqGPAkK2V", Name: "about", Size: 1677},
"contact": {Type: "File", Hash: "QmYCvbfNbCwFR45HiNP45rwJgvatpiW38D961L5qAhUM5Y", Name: "contact", Size: 189},
"help": {Type: "File", Hash: "QmY5heUM5qgRubMDD1og9fhCPA6QdkMp3QCwd4s7gJsyE7", Name: "help", Size: 311},
"quick-start": {Type: "File", Hash: "QmUzLxaXnM8RYCPEqLDX5foToi5aNZHqfYr285w2BKhkft", Name: "quick-start", Size: 1686},
"readme": {Type: "File", Hash: "QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB", Name: "readme", Size: 1091},
"security-notes": {Type: "File", Hash: "QmTumTjvcYCAvRRwQ8sDRxh8ezmrcr88YFU7iYNroGGTBZ", Name: "security-notes", Size: 1016},
}
for _, l := range list.Links {
el, ok := expected[l.Name]
is.True(ok)
is.NotNil(el)
is.Equal(*l, el)
}
}
func TestAfter(t *testing.T) {
is := is.New(t)
options := &respond.Options{}
var aftercall map[string]interface{}
options.After = func(w http.ResponseWriter, r *http.Request, status int, data interface{}) {
aftercall = map[string]interface{}{
"w": w, "r": r, "status": status, "data": data,
}
}
testHandler := &testHandler{
status: http.StatusOK, data: testdata,
}
handler := options.Handler(testHandler)
w := httptest.NewRecorder()
r := newTestRequest()
handler.ServeHTTP(w, r)
is.OK(aftercall)
is.Equal(aftercall["w"], w)
is.Equal(aftercall["r"], r)
is.Equal(aftercall["status"], testHandler.status)
is.Equal(aftercall["data"], testHandler.data)
is.Equal(http.StatusOK, w.Code)
var data map[string]interface{}
is.NoErr(json.Unmarshal(w.Body.Bytes(), &data))
is.Equal(data, testdata)
is.Equal(w.HeaderMap.Get("Content-Type"), "application/json; charset=utf-8")
}
func TestEncoderOnErr(t *testing.T) {
is := is.New(t)
var onErrCall map[string]interface{}
options := &respond.Options{
OnErr: func(err error) {
onErrCall = map[string]interface{}{"err": err}
},
}
encoderErr := errors.New("something went wrong while encoding")
options.Encoder = func(w http.ResponseWriter, r *http.Request) respond.Encoder {
return &testEncoder{
err: encoderErr,
}
}
testHandler := &testHandler{
status: http.StatusOK, data: testdata,
}
handler := options.Handler(testHandler)
w := httptest.NewRecorder()
r := newTestRequest()
handler.ServeHTTP(w, r)
is.OK(onErrCall)
is.Equal(onErrCall["err"], encoderErr)
}
func TestIDLess(t *testing.T) {
is := is.New(t)
id1 := encode(strings.NewReader(`1`)) // c42yrSHMvUcscrQBssLhrRE28YpGUv9Gf95uH8KnwTiBv4odDbVqNnCYFs3xpsLrgVZfHebSaQQsvxgDGmw5CX1fVy
id2 := encode(strings.NewReader(`2`)) // c42i2hTBA9Ej4nqEo9iUy3pJRRE53KAH9RwwMSWjmfaQN7LxCymVz1zL9hEjqeFYzxtxXz2wRK7CBtt71AFkRfHodu
is.Equal(id1.Less(id2), false)
}
func TestCompareIDs(t *testing.T) {
is := is.New(t)
for _, test := range []struct {
Id_A *asset.ID
Id_B *asset.ID
Exp int
}{
{
Id_A: encode(strings.NewReader("Test string")),
Id_B: encode(strings.NewReader("Test string")),
Exp: 0,
},
{
Id_A: encode(strings.NewReader("Test string A")),
Id_B: encode(strings.NewReader("Test string B")),
Exp: -1,
},
{
Id_A: encode(strings.NewReader("Test string B")),
Id_B: encode(strings.NewReader("Test string A")),
Exp: 1,
},
{
Id_A: encode(strings.NewReader("Test string")),
Id_B: nil,
Exp: -1,
},
} {
is.Equal(test.Id_A.Cmp(test.Id_B), test.Exp)
}
}
func TestAddFreelancer(t *testing.T) {
is := is.New(t)
freelancerRepositoryMock := &FreelancerRepositoryMock{}
freelancerContext := &ApplicationContext{
FreelancerRepository: freelancerRepositoryMock,
}
r := getRequest(freelancerContext, ``)
w := httptest.NewRecorder()
user := &User{
Model: Model{
ID: 1,
},
FirstName: "first",
LastName: "last",
Email: "*****@*****.**",
}
AddFreelancer(user).ServeHTTP(w, r)
is.Equal(w.Code, http.StatusOK)
is.Equal(freelancerRepositoryMock.AddFreelancerCall.Receives.Freelancer.User.Model.ID, 1)
is.Equal(freelancerRepositoryMock.AddFreelancerCall.Receives.Freelancer.User.FirstName, "first")
is.Equal(freelancerRepositoryMock.AddFreelancerCall.Receives.Freelancer.User.LastName, "last")
is.Equal(freelancerRepositoryMock.AddFreelancerCall.Receives.Freelancer.User.Email, "*****@*****.**")
}
func TestLogin(t *testing.T) {
is := is.New(t)
userRepositoryMock := &UserRepositoryMock{}
userRepositoryMock.CheckCredentialsCall.Returns.UserType = "freelancer"
userRepositoryMock.CheckCredentialsCall.Returns.User = User{
Model: Model{
ID: 1,
},
FirstName: "firstname",
LastName: "lastname",
Password: "******",
Email: "*****@*****.**",
}
userContext := &ApplicationContext{
UserRepository: userRepositoryMock,
}
r := getRequest(userContext, `
{
"email": "*****@*****.**",
"password": "******"
}
`)
w := httptest.NewRecorder()
Login(w, r)
is.Equal(w.Code, http.StatusOK)
var body map[string]interface{}
is.NoErr(json.Unmarshal(w.Body.Bytes(), &body))
is.Equal(body["id"], 1)
is.OK(body["token"])
is.Equal(body["type"], "freelancer")
}
func TestAddFreelancerReferenceByID(t *testing.T) {
is := is.New(t)
referenceRepositoryMock := &ReferenceRepositoryMock{}
var freelancerContext = &ApplicationContext{
ReferenceRepository: referenceRepositoryMock,
}
w := httptest.NewRecorder()
r := getRequest(freelancerContext, ``)
reference := Reference{
Title: "title",
Content: "content",
Media: Media{
Image: "image",
Video: "video",
},
}
addFreelancerReferenceByID{3, &reference}.ServeHTTP(w, r)
receivedReference := referenceRepositoryMock.AddReferenceCall.Receives.Reference
is.Equal(receivedReference.Title, "title")
is.Equal(receivedReference.Content, "content")
is.Equal(receivedReference.Media.Image, "image")
is.Equal(receivedReference.Media.Video, "video")
is.Equal(referenceRepositoryMock.AddReferenceCall.Receives.ID, 3)
}
func TestWithReference(t *testing.T) {
is := is.New(t)
referenceRepositoryMock := &ReferenceRepositoryMock{}
var freelancerContext = &ApplicationContext{
ReferenceRepository: referenceRepositoryMock,
}
w := httptest.NewRecorder()
r := getRequest(freelancerContext, `
{
"content": "content",
"title": "title",
"media": {
"image": "image",
"video": "video"
}
}`)
next := func(reference *Reference) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
is.Equal(reference.Title, "title")
is.Equal(reference.Content, "content")
is.Equal(reference.Media.Image, "image")
is.Equal(reference.Media.Video, "video")
})
}
withReference{next}.ServeHTTP(w, r)
}
func TestAddFreelancerReviewByID(t *testing.T) {
is := is.New(t)
freelancerRepositoryMock := &FreelancerRepositoryMock{}
var freelancerContext = &ApplicationContext{
FreelancerRepository: freelancerRepositoryMock,
}
w := httptest.NewRecorder()
r := getRequest(freelancerContext, ``)
review := Review{
Title: "title",
ClientID: 2,
Content: "content",
JobID: 4,
Rating: 5.6,
}
addFreelancerReviewByID{3, &review}.ServeHTTP(w, r)
receivedReview := freelancerRepositoryMock.AddReviewCall.Receives.Review
is.Equal(receivedReview.Title, "title")
is.Equal(receivedReview.Content, "content")
is.Equal(receivedReview.Rating, 5.6)
is.Equal(receivedReview.ClientID, 2)
is.Equal(receivedReview.JobID, 4)
is.Equal(freelancerRepositoryMock.AddReviewCall.Receives.ID, 3)
}
func TestAddClient(t *testing.T) {
is := is.New(t)
clientRepositoryMock := &ClientRepositoryMock{}
userContext := &ApplicationContext{
ClientRepository: clientRepositoryMock,
}
r := getRequest(userContext, ``)
w := httptest.NewRecorder()
user := &User{
Model: Model{
ID: 1,
},
}
AddClient(user).ServeHTTP(w, r)
is.Equal(w.Code, http.StatusOK)
is.Equal(clientRepositoryMock.AddClientCall.Receives.Client.User.ID, 1)
var body map[string]interface{}
is.NoErr(json.Unmarshal(w.Body.Bytes(), &body))
userMap := body["user"].(map[string]interface{})
is.Equal(userMap["id"], 1)
is.Equal(body["type"], "client")
}
func TestBytesToID(t *testing.T) {
is := is.New(t)
b := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58}
id := asset.BytesToID(b)
is.Equal(id.String(), "c41111111111111111111111111111111111111111111111111111111111111111111111111111111111111121")
}
func TestUpdateClientByID(t *testing.T) {
is := is.New(t)
clientRepositoryMock := &ClientRepositoryMock{}
clientRepositoryMock.GetClientCall.Returns.Client = &Client{
User: User{
Model: Model{
ID: 1,
},
},
}
userContext := &ApplicationContext{
ClientRepository: clientRepositoryMock,
}
r := getRequest(userContext, `
{
"timezone": "UTC",
"payment": "paypal",
"industry": "feet cartoon drawings"
}`)
w := httptest.NewRecorder()
UpdateClientByID(1).ServeHTTP(w, r)
is.Equal(w.Code, http.StatusOK)
is.Equal(clientRepositoryMock.GetClientCall.Receives.ID, 1)
is.Equal(clientRepositoryMock.UpdateClientCall.Receives.Client.Timezone, "UTC")
is.Equal(clientRepositoryMock.UpdateClientCall.Receives.Client.Payment, "paypal")
is.Equal(clientRepositoryMock.UpdateClientCall.Receives.Client.Industry, "feet cartoon drawings")
}
func TestNILID(t *testing.T) {
is := is.New(t)
// ID of nothing constant
nilid := asset.NIL_ID
is.Equal(nilid.String(), "c459CSJESBh38BxDwwxNFKTXE4cC9HASGe3bhtN6z58GbwLqpCyRaKyZSvBAvTdF5NpSTPdUMH4hHRJ75geLsB1Sfs")
}
func TestEncoder(t *testing.T) {
is := is.New(t)
options := &respond.Options{}
var encodercall map[string]interface{}
options.Encoder = func(w http.ResponseWriter, r *http.Request) respond.Encoder {
encodercall = map[string]interface{}{
"w": w, "r": r,
}
return &testEncoder{}
}
testHandler := &testHandler{
status: http.StatusOK, data: testdata,
}
handler := options.Handler(testHandler)
w := httptest.NewRecorder()
r := newTestRequest()
handler.ServeHTTP(w, r)
is.OK(encodercall)
is.Equal(encodercall["w"], w)
is.Equal(encodercall["r"], r)
is.Equal(http.StatusOK, w.Code)
is.Equal(w.Body.String(), "testEncoder")
is.Equal(w.HeaderMap.Get("Content-Type"), "test/encoder")
}
func TestAppendOrder(t *testing.T) {
is := is.New(t)
byteData := [4][]byte{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0d, 0x24},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0xfa, 0x28},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xac, 0xad, 0x10},
}
expectedIDs := [4]string{
`c41111111111111111111111111111111111111111111111111111111111111111111111111111111111111121`,
`c41111111111111111111111111111111111111111111111111111111111111111111111111111111111111211`,
`c41111111111111111111111111111111111111111111111111111111111111111111111111111111111112111`,
`c41111111111111111111111111111111111111111111111111111111111111111111111111111111111121111`,
}
for k := 0; k < 4; k++ {
b := byteData[k]
bignum := big.NewInt(0)
bignum = bignum.SetBytes(b)
id := asset.ID(*bignum)
is.Equal(id.String(), expectedIDs[k])
id2, err := asset.ParseID(expectedIDs[k])
is.NoErr(err)
bignum2 := big.Int(*id2)
b = (&bignum2).Bytes()
size := len(b)
for size < 64 {
b = append([]byte{0}, b...)
size++
}
for i, bb := range b {
is.Equal(bb, byteData[k][i])
}
}
}
func TestMultipleWith(t *testing.T) {
is := is.New(t)
options := &respond.Options{}
handler := options.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
respond.With(w, r, http.StatusInternalServerError, errors.New("borked"))
respond.With(w, r, http.StatusOK, nil)
}))
w := httptest.NewRecorder()
r := newTestRequest()
is.PanicWith("respond: multiple responses", func() {
handler.ServeHTTP(w, r)
})
options = &respond.Options{
AllowMultiple: true,
}
handler = options.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
respond.With(w, r, http.StatusInternalServerError, errors.New("borked"))
respond.With(w, r, http.StatusOK, nil)
}))
w = httptest.NewRecorder()
r = newTestRequest()
handler.ServeHTTP(w, r)
}
func TestIdentify(t *testing.T) {
is := is.New(t)
id, err := asset.Identify(iotest.DataErrReader(strings.NewReader("foo")))
is.NoErr(err)
is.Equal(id.String(), "c45XyDwWmrPQwJPdULBhma6LGNaLghKtN7R9vLn2tFrepZJ9jJFSDzpCKei11EgA5r1veenBu3Q8qfvWeDuPc7fJK2")
}
func TestIDofIDSlice(t *testing.T) {
is := is.New(t)
var b, s []byte
for i := 0; i < 64; i++ {
b = append(b, 0xFF)
s = append(s, 0x00)
}
bigBig := big.NewInt(0)
bigSmall := big.NewInt(0)
bigBig = bigBig.SetBytes(b)
bigSmall = bigSmall.SetBytes(s)
bigID := asset.ID(*bigBig)
smallID := asset.ID(*bigSmall)
encoder := asset.NewIDEncoder()
is.OK(encoder)
_, err := io.Copy(encoder, strings.NewReader(`c41111111111111111111111111111111111111111111111111111111111111111111111111111111111111111c467RPWkcUr5dga8jgywjSup7CMoA9FNqkNjEFgAkEpF9vNktFnx77e2Js11EDL3BNu9MaKFUbacZRt1HYym4b8RNp`))
is.NoErr(err)
id := encoder.ID()
var idSlice asset.IDSlice
idSlice.Push(&bigID)
idSlice.Push(&smallID)
sliceID, err := idSlice.ID()
is.NoErr(err)
is.Equal(sliceID.String(), id.String())
}
func TestWithUser(t *testing.T) {
is := is.New(t)
userContext := &ApplicationContext{}
r := getRequest(userContext, `
{
"firstName": "firstname",
"lastName": "lastname",
"email": "*****@*****.**",
"password": "******"
}
`)
w := httptest.NewRecorder()
withUser := WithUser{
next: func(u *User) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
is.Equal(u.FirstName, "firstname")
is.Equal(u.LastName, "lastname")
is.Equal(u.Email, "*****@*****.**")
is.Equal(u.Password, "password")
})
},
}
withUser.ServeHTTP(w, r)
is.Equal(w.Code, http.StatusOK)
}
func TestPatch_rmLink(t *testing.T) {
is := is.New(t)
s := NewShell(shellUrl)
newRoot, err := s.Patch(examplesHash, "rm-link", "about")
is.Nil(err)
is.Equal(newRoot, "QmNjJ3naRhHCn14E895R1xtGmDgKQb8vnVvQar6RrnraC1")
}
func TestOnceReset(t *testing.T) {
is := is.New(t)
var calls int
var c resync.Once
c.Do(func() {
calls++
})
c.Do(func() {
calls++
})
c.Do(func() {
calls++
})
is.Equal(calls, 1)
c.Reset()
c.Do(func() {
calls++
})
c.Do(func() {
calls++
})
c.Do(func() {
calls++
})
is.Equal(calls, 2)
}
func TestProjectGetByID(t *testing.T) {
projectRepositoryMock := ProjectRepositoryMock{}
projectRepositoryMock.GetByIDCall.Returns.Project = Project{
Model: Model{
ID: 123456789,
},
Name: "Name1",
Description: "Description1",
ClientID: 1,
IsActive: true,
}
var context = &ApplicationContext{
ProjectRepository: &projectRepositoryMock,
}
is := is.New(t)
w := httptest.NewRecorder()
r := getRequest(context, "")
GetProjectByID(0).ServeHTTP(w, r)
is.Equal(w.Code, http.StatusOK)
var body Project
is.NoErr(json.Unmarshal(w.Body.Bytes(), &body))
is.Equal(body.Model.ID, uint(123456789))
is.Equal(body.Name, "Name1")
is.Equal(body.Description, "Description1")
is.Equal(body.IsActive, true)
}
func TestPlaceJSON(t *testing.T) {
is := is.New(t)
var e meander.Place
j := `{
"geometry" : {
"location" : {
"lat" : -33.870775,
"lng" : 151.199025
}
},
"icon" : "http://maps.gstatic.com/mapfiles/place_api/icons/travel_agent-71.png",
"id" : "21a0b251c9b8392186142c798263e289fe45b4aa",
"name" : "Rhythmboat Cruises"
}`
is.NoErr(json.NewDecoder(strings.NewReader(j)).Decode(&e))
is.Equal("Rhythmboat Cruises", e.Name)
is.Equal("http://maps.gstatic.com/mapfiles/place_api/icons/travel_agent-71.png", e.Icon)
is.Equal(-33.870775, e.Lat)
is.Equal(151.199025, e.Lng)
}
func TestCostRangeString(t *testing.T) {
is := is.New(t)
is.Equal("$$...$$$$", (&meander.CostRange{
From: meander.Cost2,
To: meander.Cost4,
}).String())
}
func TestUpdateFreelancerHandler(t *testing.T) {
is := is.New(t)
freelancerRepositoryMock := &FreelancerRepositoryMock{}
freelancerRepositoryMock.GetFreelancerCall.Returns.Freelancer = Freelancer{
User: User{
Model: Model{
ID: 1,
},
},
}
var freelancerContext = &ApplicationContext{
FreelancerRepository: freelancerRepositoryMock,
}
w := httptest.NewRecorder()
r := getRequest(freelancerContext, ``)
updateFreelancerHandler{1, &FreelancerUpdate{
HourlyRateFrom: 11,
HourlyRateTo: 22,
IsAvailable: true,
Timezone: "timez",
Skills: stringList{"one", "two"},
}}.ServeHTTP(w, r)
freelancer := freelancerRepositoryMock.UpdateFreelancerCall.Receives.Freelancer
is.Equal(w.Code, http.StatusOK)
is.Equal(freelancer.HourlyRateFrom, 11)
is.Equal(freelancer.HourlyRateTo, 22)
is.Equal(freelancer.IsAvailable, true)
is.Equal(freelancer.Timezone, "timez")
is.Equal(freelancer.Skills[0], "one")
is.Equal(freelancer.Skills[1], "two")
}