func TestAdminAPIUsers(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
ts := s.(*TestServer)
// Create sample users.
session := sql.NewSession(
context.Background(), sql.SessionArgs{User: security.RootUser}, ts.sqlExecutor, nil)
query := `
INSERT INTO system.users (username, hashedPassword)
VALUES ('admin', 'abc'), ('bob', 'xyz')`
res := ts.sqlExecutor.ExecuteStatements(session, query, nil)
if a, e := len(res.ResultList), 1; a != e {
t.Fatalf("len(results) %d != %d", a, e)
} else if res.ResultList[0].Err != nil {
t.Fatal(res.ResultList[0].Err)
}
// Query the API for users.
var resp serverpb.UsersResponse
if err := apiGet(s, "users", &resp); err != nil {
t.Fatal(err)
}
expResult := serverpb.UsersResponse{
Users: []serverpb.UsersResponse_User{
{Username: "******"},
{Username: "******"},
},
}
// Verify results.
const sortKey = "Username"
testutils.SortStructs(resp.Users, sortKey)
testutils.SortStructs(expResult.Users, sortKey)
if !reflect.DeepEqual(resp, expResult) {
t.Fatalf("result %v != expected %v", resp, expResult)
}
}
func TestAdminAPIUsers(t *testing.T) {
defer leaktest.AfterTest(t)()
s := StartTestServer(t)
defer s.Stop()
// Create sample users.
var session sql.Session
query := `
INSERT INTO system.users (username, hashedPassword)
VALUES ('admin', 'abc'), ('bob', 'xyz')`
res := s.sqlExecutor.ExecuteStatements(security.RootUser, &session, query, nil)
if a, e := len(res.ResultList), 1; a != e {
t.Fatalf("len(results) %d != %d", a, e)
} else if res.ResultList[0].PErr != nil {
t.Fatal(res.ResultList[0].PErr)
}
// Query the API for users.
var resp UsersResponse
if err := apiGet(s, "users", &resp); err != nil {
t.Fatal(err)
}
expResult := UsersResponse{
Users: []*UsersResponse_User{
{"admin"},
{"bob"},
},
}
// Verify results.
const sortKey = "Username"
testutils.SortStructs(resp.Users, sortKey)
testutils.SortStructs(expResult.Users, sortKey)
if !reflect.DeepEqual(resp, expResult) {
t.Fatalf("result %v != expected %v", resp, expResult)
}
}
func TestAdminAPITableDetails(t *testing.T) {
defer leaktest.AfterTest(t)()
s := StartTestServer(t)
defer s.Stop()
session := sql.NewSession(sql.SessionArgs{User: security.RootUser}, s.sqlExecutor, nil)
setupQueries := []string{
"CREATE DATABASE test",
`
CREATE TABLE test.tbl (
nulls_allowed INT,
nulls_not_allowed INT NOT NULL DEFAULT 1000,
default2 INT DEFAULT 2,
string_default STRING DEFAULT 'default_string'
)`,
"GRANT SELECT ON test.tbl TO readonly",
"GRANT SELECT,UPDATE,DELETE ON test.tbl TO app",
"CREATE INDEX descIdx ON test.tbl (default2 DESC)",
}
for _, q := range setupQueries {
res := s.sqlExecutor.ExecuteStatements(session, q, nil)
if res.ResultList[0].PErr != nil {
t.Fatalf("error executing '%s': %s", q, res.ResultList[0].PErr)
}
}
// Perform API call.
var resp TableDetailsResponse
if err := apiGet(s, "databases/test/tables/tbl", &resp); err != nil {
t.Fatal(err)
}
// Verify columns.
expColumns := []TableDetailsResponse_Column{
{Name: "nulls_allowed", Type: "INT", Nullable: true, Default: ""},
{Name: "nulls_not_allowed", Type: "INT", Nullable: false, Default: "1000"},
{Name: "default2", Type: "INT", Nullable: true, Default: "2"},
{Name: "string_default", Type: "STRING", Nullable: true, Default: "'default_string'"},
{Name: "rowid", Type: "INT", Nullable: false, Default: "unique_rowid()"},
}
testutils.SortStructs(expColumns, "Name")
testutils.SortStructs(resp.Columns, "Name")
if a, e := len(resp.Columns), len(expColumns); a != e {
t.Fatalf("# of result columns %d != expected %d (got: %#v)", a, e, resp.Columns)
}
for i, a := range resp.Columns {
e := expColumns[i]
if a.String() != e.String() {
t.Fatalf("mismatch at index %d: actual %#v != %#v", i, a, e)
}
}
// Verify grants.
expGrants := []TableDetailsResponse_Grant{
{User: security.RootUser, Privileges: []string{"ALL"}},
{User: "******", Privileges: []string{"DELETE", "SELECT", "UPDATE"}},
{User: "******", Privileges: []string{"SELECT"}},
}
testutils.SortStructs(expGrants, "User")
testutils.SortStructs(resp.Grants, "User")
if a, e := len(resp.Grants), len(expGrants); a != e {
t.Fatalf("# of grant columns %d != expected %d (got: %#v)", a, e, resp.Grants)
}
for i, a := range resp.Grants {
e := expGrants[i]
sort.Strings(a.Privileges)
sort.Strings(e.Privileges)
if a.String() != e.String() {
t.Fatalf("mismatch at index %d: actual %#v != %#v", i, a, e)
}
}
// Verify indexes.
expIndexes := []TableDetailsResponse_Index{
{Name: "primary", Column: "rowid", Direction: "ASC", Unique: true, Seq: 1},
{Name: "descIdx", Column: "default2", Direction: "DESC", Unique: false, Seq: 1},
}
testutils.SortStructs(expIndexes, "Column")
testutils.SortStructs(resp.Indexes, "Column")
for i, a := range resp.Indexes {
e := expIndexes[i]
if a.String() != e.String() {
t.Fatalf("mismatch at index %d: actual %#v != %#v", i, a, e)
}
}
if a, e := resp.RangeCount, int64(1); a != e {
t.Fatalf("# of ranges %d != expected %d", a, e)
}
}