package who
import "encoding/json"
import "net/http"
import "net/http/httptest"
import "testing"
func TestListGroups(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/list" {
t.Errorf("path: got %q, want /groups/list",
r.URL.Path)
}
if r.Header.Get("Authorization") !=
"Bearer test-key" {
t.Errorf("Authorization: got %q",
r.Header.Get("Authorization"))
}
w.Header().Set(
"Content-Type", "application/json")
json.NewEncoder(w).Encode(listGroupsResponse{
Groups: []Group{
{
Username: "team",
Name: "Team",
OwnerUsername: "alice",
},
{
Username: "admins",
Name: "Admins",
OwnerUsername: "alice",
},
},
})
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
groups, err := c.ListGroups()
if err != nil {
t.Fatal(err)
}
if len(groups) != 2 {
t.Fatalf("len: got %d, want 2", len(groups))
}
if groups[0].Username != "team" {
t.Errorf(
"groups[0].Username: got %q, want team",
groups[0].Username)
}
if groups[1].OwnerUsername != "alice" {
t.Errorf(
"groups[1].OwnerUsername: got %q, want alice",
groups[1].OwnerUsername)
}
}
func TestListGroupsHTTPError(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(401)
w.Write([]byte("not authenticated"))
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "bad-key")
_, err := c.ListGroups()
if err == nil {
t.Fatal("want error on 401, got nil")
}
}
func TestGetProfile(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/login/profile/get" {
t.Errorf(
"path: got %q, want /login/profile/get",
r.URL.Path)
}
w.Header().Set(
"Content-Type", "application/json")
json.NewEncoder(w).Encode(Profile{
Username: "alice",
Name: "Alice Liddell",
Email: "[email protected]",
Groups: []string{"team", "admins"},
})
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
p, err := c.GetProfile()
if err != nil {
t.Fatal(err)
}
if p.Username != "alice" {
t.Errorf(
"Username: got %q, want alice", p.Username)
}
if len(p.Groups) != 2 {
t.Errorf(
"Groups: got %d, want 2", len(p.Groups))
}
}
func TestCreateGroup(t *testing.T) {
var seen CreateGroupRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/add" {
t.Errorf(
"path: got %q, want /groups/add",
r.URL.Path)
}
if r.Method != "POST" {
t.Errorf("method: got %q, want POST", r.Method)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(200)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.CreateGroup(CreateGroupRequest{
Username: "team",
Name: "Team",
OwnerUsername: "alice",
})
if err != nil {
t.Fatal(err)
}
if seen.Username != "team" {
t.Errorf(
"Username: got %q, want team", seen.Username)
}
if seen.OwnerUsername != "alice" {
t.Errorf(
"OwnerUsername: got %q, want alice",
seen.OwnerUsername)
}
}
func TestGroupMembers(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/members" {
t.Errorf(
"path: got %q, want /groups/members",
r.URL.Path)
}
var body map[string]string
json.NewDecoder(r.Body).Decode(&body)
if body["owid"] != "team-owid" {
t.Errorf(
"owid: got %q, want team-owid", body["owid"])
}
json.NewEncoder(w).Encode(GroupMembersResponse{
Down: [][]string{
{"alice-owid", "bob-owid"},
},
Usernames: map[string]string{
"alice-owid": "alice",
"bob-owid": "bob",
},
})
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
res, err := c.GroupMembers("team-owid")
if err != nil {
t.Fatal(err)
}
if res.Usernames["alice-owid"] != "alice" {
t.Errorf(
"Usernames[alice-owid]: got %q",
res.Usernames["alice-owid"])
}
}
func TestLeaveGroup(t *testing.T) {
var seen LeaveGroupRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/leave" {
t.Errorf(
"path: got %q, want /groups/leave",
r.URL.Path)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(204)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.LeaveGroup(LeaveGroupRequest{
GroupOwid: "team-owid",
MemberOwid: "alice-owid",
})
if err != nil {
t.Fatal(err)
}
if seen.GroupOwid != "team-owid" {
t.Errorf(
"GroupOwid: got %q", seen.GroupOwid)
}
if seen.MemberOwid != "alice-owid" {
t.Errorf(
"MemberOwid: got %q", seen.MemberOwid)
}
}
func TestListAuthz(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/authz/list" {
t.Errorf(
"path: got %q, want /authz/list", r.URL.Path)
}
json.NewEncoder(w).Encode(listAuthzResponse{
Uris: []AuthzEntry{
{
Uri: "chat://team#post",
Owner: &User{
Owid: "team-owid", Username: "team"},
Reader: &User{
Owid: "team-owid", Username: "team"},
IsOwner: true,
IsReader: true,
},
},
})
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
uris, err := c.ListAuthz()
if err != nil {
t.Fatal(err)
}
if len(uris) != 1 {
t.Fatalf("len: got %d, want 1", len(uris))
}
if uris[0].Uri != "chat://team#post" {
t.Errorf(
"Uri: got %q, want chat://team#post", uris[0].Uri)
}
if uris[0].Owner.Username != "team" {
t.Errorf(
"Owner.Username: got %q", uris[0].Owner.Username)
}
}
func TestSetAuthz(t *testing.T) {
var seen []AuthzSetRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/authz/set" {
t.Errorf("path: got %q", r.URL.Path)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(204)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.SetAuthz(AuthzSetRequest{
Uri: "chat://team#post",
OwnerUsername: "team",
ReaderUsername: "team",
})
if err != nil {
t.Fatal(err)
}
if len(seen) != 1 {
t.Fatalf("len: got %d, want 1", len(seen))
}
if seen[0].Uri != "chat://team#post" {
t.Errorf("Uri: got %q", seen[0].Uri)
}
if seen[0].OwnerUsername != "team" {
t.Errorf("OwnerUsername: got %q", seen[0].OwnerUsername)
}
}
// TestSetAuthzMulti covers the multi-entry wire shape: array on
// the wire, all entries seen by the server.
func TestSetAuthzMulti(t *testing.T) {
var seen []AuthzSetRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(204)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.SetAuthzMulti([]AuthzSetRequest{
{
Uri: "chat://team#post",
OwnerUsername: "team",
ReaderUsername: "team",
},
{
Uri: "chat://team#read",
OwnerUsername: "team",
ReaderUsername: "team",
},
})
if err != nil {
t.Fatal(err)
}
if len(seen) != 2 {
t.Fatalf("len: got %d, want 2", len(seen))
}
}
func TestDeleteAuthz(t *testing.T) {
var seen AuthzDeleteRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/authz/delete" {
t.Errorf("path: got %q", r.URL.Path)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(204)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.DeleteAuthz(AuthzDeleteRequest{
Uri: "chat://team#post",
})
if err != nil {
t.Fatal(err)
}
if seen.Uri != "chat://team#post" {
t.Errorf("Uri: got %q", seen.Uri)
}
}
func TestDeleteGroup(t *testing.T) {
var seen DeleteGroupRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/delete" {
t.Errorf(
"path: got %q, want /groups/delete",
r.URL.Path)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(200)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.DeleteGroup(DeleteGroupRequest{
Owid: "team-owid",
})
if err != nil {
t.Fatal(err)
}
if seen.Owid != "team-owid" {
t.Errorf("Owid: got %q, want team-owid", seen.Owid)
}
}
func TestJoinGroups(t *testing.T) {
var seen JoinGroupsRequest
srv := httptest.NewServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/groups/join" {
t.Errorf(
"path: got %q, want /groups/join",
r.URL.Path)
}
if r.Method != "POST" {
t.Errorf("method: got %q, want POST", r.Method)
}
json.NewDecoder(r.Body).Decode(&seen)
w.WriteHeader(200)
}))
defer srv.Close()
c := NewHTTPClient(srv.URL, "test-key")
err := c.JoinGroups(JoinGroupsRequest{
GroupUsernames: []string{"team"},
MemberUsernames: []string{"alice", "bob"},
})
if err != nil {
t.Fatal(err)
}
if len(seen.GroupUsernames) != 1 ||
seen.GroupUsernames[0] != "team" {
t.Errorf(
"GroupUsernames: got %v, want [team]",
seen.GroupUsernames)
}
if len(seen.MemberUsernames) != 2 {
t.Errorf(
"MemberUsernames: got %v, want 2 members",
seen.MemberUsernames)
}
}