diff --git a/pkg/platform/owner_test.go b/pkg/platform/owner_test.go new file mode 100644 index 0000000000..8e84d6d28e --- /dev/null +++ b/pkg/platform/owner_test.go @@ -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 +} diff --git a/pkg/platform/remotecommand/protocol_test.go b/pkg/platform/remotecommand/protocol_test.go new file mode 100644 index 0000000000..6b4dc158c0 --- /dev/null +++ b/pkg/platform/remotecommand/protocol_test.go @@ -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) +} diff --git a/pkg/platform/version_test.go b/pkg/platform/version_test.go new file mode 100644 index 0000000000..e420b57c87 --- /dev/null +++ b/pkg/platform/version_test.go @@ -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 +}