Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
116 changes: 116 additions & 0 deletions pkg/platform/owner_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,116 @@
package platform

import (
"testing"

managementv1 "github.com/devsy-org/api/pkg/apis/management/v1"
storagev1 "github.com/devsy-org/api/pkg/apis/storage/v1"
"github.com/stretchr/testify/suite"
)

const (
ownerTestUser = "alice"
ownerTestTeam = "devs"
)

type ownerSuite struct {
suite.Suite
}

func TestOwnerSuite(t *testing.T) {
suite.Run(t, new(ownerSuite))
}

func (s *ownerSuite) TestIsOwnerMatchesUserName() {
self := s.self(s.userInfo(ownerTestUser), nil)
s.True(IsOwner(self, &storagev1.UserOrTeam{User: ownerTestUser}))
}

func (s *ownerSuite) TestIsOwnerRejectsDifferentUser() {
self := s.self(s.userInfo(ownerTestUser), nil)
s.False(IsOwner(self, &storagev1.UserOrTeam{User: "bob"}))
}

func (s *ownerSuite) TestIsOwnerMatchesTeamMembership() {
self := s.self(s.userInfo(ownerTestUser, ownerTestTeam), nil)
s.True(IsOwner(self, &storagev1.UserOrTeam{Team: ownerTestTeam}))
s.False(IsOwner(self, &storagev1.UserOrTeam{Team: "other"}))
}

// The acting team owns its resources even when the user is not a member.
func (s *ownerSuite) TestIsOwnerMatchesActingTeam() {
self := s.self(
s.userInfo(ownerTestUser),
&storagev1.EntityInfo{Name: ownerTestTeam},
)
s.True(IsOwner(self, &storagev1.UserOrTeam{Team: ownerTestTeam}))
s.False(IsOwner(self, &storagev1.UserOrTeam{Team: "other"}))
}

func (s *ownerSuite) TestIsOwnerHandlesNilInputs() {
self := s.self(s.userInfo(ownerTestUser), nil)
s.False(IsOwner(nil, &storagev1.UserOrTeam{User: ownerTestUser}))
s.False(IsOwner(self, nil))
s.False(IsOwner(nil, nil))
}

// An empty user name matches an empty UserOrTeam, since both sides are empty
// strings. Tightening this is an authorization change, so the test pins the
// present behavior rather than asserting it is correct.
func (s *ownerSuite) TestIsOwnerEmptyNamesCurrentlyMatch() {
self := s.self(&managementv1.UserInfo{}, &storagev1.EntityInfo{})
s.True(IsOwner(self, &storagev1.UserOrTeam{}))

// A resolved name does not match, so the match above is the both-empty case.
named := s.self(s.userInfo(ownerTestUser), nil)
s.False(IsOwner(named, &storagev1.UserOrTeam{}))
}

func (s *ownerSuite) TestUserIsOwnerHandlesNilUser() {
s.False(userIsOwner(nil, &storagev1.UserOrTeam{User: ownerTestUser}))
}

func (s *ownerSuite) TestOwnerFilterSetAcceptsKnownValues() {
for _, tc := range []struct {
in string
want OwnerFilter
}{
{"", SelfOwnerFilter},
{"self", SelfOwnerFilter},
{"all", AllOwnerFilter},
} {
var filter OwnerFilter
s.Require().NoError(filter.Set(tc.in), "input %q", tc.in)
s.Equal(tc.want, filter, "input %q", tc.in)
}
}

func (s *ownerSuite) TestOwnerFilterSetRejectsUnknownValue() {
var filter OwnerFilter
err := filter.Set("everything")
s.Require().Error(err)
s.Contains(err.Error(), "everything")
}

func (s *ownerSuite) TestOwnerFilterTypeAndString() {
filter := AllOwnerFilter
s.Equal("ownerFilter", filter.Type())
s.Equal("all", filter.String())
}

func (s *ownerSuite) self(
user *managementv1.UserInfo,
team *storagev1.EntityInfo,
) *managementv1.Self {
return &managementv1.Self{
Status: managementv1.SelfStatus{User: user, Team: team},
}
}

func (s *ownerSuite) userInfo(teams ...string) *managementv1.UserInfo {
info := &managementv1.UserInfo{EntityInfo: storagev1.EntityInfo{Name: ownerTestUser}}
for _, team := range teams {
info.Teams = append(info.Teams, &storagev1.EntityInfo{Name: team})
}
return info
}
80 changes: 80 additions & 0 deletions pkg/platform/remotecommand/protocol_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,80 @@
package remotecommand

import (
"bytes"
"io"
"testing"

"github.com/stretchr/testify/suite"
)

type protocolSuite struct {
suite.Suite
}

func TestProtocolSuite(t *testing.T) {
suite.Run(t, new(protocolSuite))
}

func (s *protocolSuite) TestDataMessageRoundTrip() {
original := newDataMessage(StdoutData, []byte("hello"))
encoded := original.Bytes()
s.Equal([]byte{byte(StdoutData), 'h', 'e', 'l', 'l', 'o'}, encoded)

parsed, err := ParseMessage(bytes.NewReader(encoded))
s.Require().NoError(err)
s.Equal(StdoutData, parsed.messageType)
payload, err := io.ReadAll(parsed.data)
s.Require().NoError(err)
s.Equal("hello", string(payload))
}

func (s *protocolSuite) TestCloseMessagesCarryNoPayload() {
for _, messageType := range []MessageType{StdoutClose, StderrClose, StdinClose} {
encoded := newCloseMessage(messageType).Bytes()
s.Equal([]byte{byte(messageType)}, encoded)

parsed, err := ParseMessage(bytes.NewReader(encoded))
s.Require().NoError(err, "type %d", messageType)
s.Equal(messageType, parsed.messageType, "type %d", messageType)
s.Nil(parsed.data, "type %d", messageType)
}
}

func (s *protocolSuite) TestExitCodeRoundTrip() {
original := NewExitCodeMessage(42)
encoded := original.Bytes()
s.Equal(byte(ExitCode), encoded[0])

parsed, err := ParseMessage(bytes.NewReader(encoded))
s.Require().NoError(err)
s.Equal(ExitCode, parsed.messageType)
s.Equal(int64(42), parsed.exitCode)
}

func (s *protocolSuite) TestExitCodeRoundTripNegative() {
encoded := NewExitCodeMessage(-1).Bytes()
parsed, err := ParseMessage(bytes.NewReader(encoded))
s.Require().NoError(err)
s.Equal(ExitCode, parsed.messageType)
s.Equal(int64(-1), parsed.exitCode)
}

func (s *protocolSuite) TestParseRejectsUnknownMessageType() {
_, err := ParseMessage(bytes.NewReader([]byte{99}))
s.Require().Error(err)
// Rendered in binary, matching the production error.
s.Contains(err.Error(), "1100011")
}

func (s *protocolSuite) TestParseRejectsTruncatedExitCode() {
// A type byte with no varint payload behind it.
_, err := ParseMessage(bytes.NewReader([]byte{byte(ExitCode)}))
s.Require().Error(err)
s.Contains(err.Error(), "read exit code")
}

func (s *protocolSuite) TestParseReturnsErrorOnEmptyInput() {
_, err := ParseMessage(bytes.NewReader(nil))
s.ErrorIs(err, io.EOF)
}
101 changes: 101 additions & 0 deletions pkg/platform/version_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,101 @@
package platform

import (
"net/http"
"net/http/httptest"
"testing"

"github.com/stretchr/testify/suite"
)

type versionSuite struct {
suite.Suite
}

func TestVersionSuite(t *testing.T) {
suite.Run(t, new(versionSuite))
}

func (s *versionSuite) TestGetPlatformVersionParsesBothFields() {
url := s.serve(http.StatusOK, `{"version":"1.2.3","devsyVersion":"v0.4.5"}`)

got, err := GetPlatformVersion(url)
s.Require().NoError(err)
s.Equal("1.2.3", got.Version)
s.Equal("v0.4.5", got.DevsyVersion)
}

func (s *versionSuite) TestGetPlatformVersionOmitsAbsentFields() {
url := s.serve(http.StatusOK, `{}`)

got, err := GetPlatformVersion(url)
s.Require().NoError(err)
s.Empty(got.Version)
s.Empty(got.DevsyVersion)
}

func (s *versionSuite) TestGetPlatformVersionReportsStatusAndBody() {
url := s.serve(http.StatusForbidden, "nope")

_, err := GetPlatformVersion(url)
s.Require().Error(err)
s.Contains(err.Error(), "nope")
s.Contains(err.Error(), "403")
}

func (s *versionSuite) TestGetPlatformVersionRejectsMalformedJSON() {
url := s.serve(http.StatusOK, "not json")

_, err := GetPlatformVersion(url)
s.Require().Error(err)
s.Contains(err.Error(), "parse")
}

func (s *versionSuite) TestGetDevsyVersionAddsMissingVPrefix() {
url := s.serve(http.StatusOK, `{"devsyVersion":"0.4.5"}`)

got, err := GetDevsyVersion(url)
s.Require().NoError(err)
s.Equal("v0.4.5", got)
}

func (s *versionSuite) TestGetDevsyVersionKeepsExistingVPrefix() {
url := s.serve(http.StatusOK, `{"devsyVersion":"v0.4.5"}`)

got, err := GetDevsyVersion(url)
s.Require().NoError(err)
s.Equal("v0.4.5", got)
}

// The error must point at --version, since a missing devsyVersion is a
// provider-version problem.
func (s *versionSuite) TestGetDevsyVersionRequiresDevsyVersion() {
url := s.serve(http.StatusOK, `{"version":"1.2.3"}`)

_, err := GetDevsyVersion(url)
s.Require().Error(err)
s.Contains(err.Error(), "--version")
}

func (s *versionSuite) TestGetDevsyVersionPropagatesFetchError() {
server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {}))
url := server.URL
server.Close()

_, err := GetDevsyVersion(url)
s.Require().Error(err)
s.Contains(err.Error(), "get")
}

func (s *versionSuite) serve(status int, body string) string {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/version" {
w.WriteHeader(http.StatusNotFound)
return
}
w.WriteHeader(status)
_, _ = w.Write([]byte(body))
}))
s.T().Cleanup(server.Close)
return server.URL
}
Loading