From 2dbe64e92a9b00a0d14f4da610208f506938912c Mon Sep 17 00:00:00 2001 From: Oleg Isakov Date: Thu, 27 Mar 2025 12:38:51 +0200 Subject: [PATCH 1/2] add racks cmd --- cmd/entities/racks/get.go | 39 +++++++++++++++++++++++ cmd/entities/racks/list.go | 21 +++++++++++++ cmd/entities/racks/rack.go | 39 +++++++++++++++++++++++ cmd/entities/racks/update.go | 54 ++++++++++++++++++++++++++++++++ cmd/root.go | 2 ++ internal/output/entities/init.go | 1 + internal/output/entities/rack.go | 28 +++++++++++++++++ 7 files changed, 184 insertions(+) create mode 100644 cmd/entities/racks/get.go create mode 100644 cmd/entities/racks/list.go create mode 100644 cmd/entities/racks/rack.go create mode 100644 cmd/entities/racks/update.go create mode 100644 internal/output/entities/rack.go diff --git a/cmd/entities/racks/get.go b/cmd/entities/racks/get.go new file mode 100644 index 0000000..8afb40f --- /dev/null +++ b/cmd/entities/racks/get.go @@ -0,0 +1,39 @@ +package racks + +import ( + "github.com/serverscom/srvctl/cmd/base" + "github.com/spf13/cobra" +) + +func newGetCmd(cmdContext *base.CmdContext) *cobra.Command { + cmd := &cobra.Command{ + Use: "get ", + Short: "Get a private rack", + Long: "Get a private rack by id", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + manager := cmdContext.GetManager() + + ctx, cancel := base.SetupContext(cmd, manager) + defer cancel() + + base.SetupProxy(cmd, manager) + + scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient() + + id := args[0] + rack, err := scClient.Racks.Get(ctx, id) + if err != nil { + return err + } + + if rack != nil { + formatter := cmdContext.GetOrCreateFormatter(cmd) + return formatter.Format(rack) + } + return nil + }, + } + + return cmd +} diff --git a/cmd/entities/racks/list.go b/cmd/entities/racks/list.go new file mode 100644 index 0000000..78bf9f7 --- /dev/null +++ b/cmd/entities/racks/list.go @@ -0,0 +1,21 @@ +package racks + +import ( + serverscom "github.com/serverscom/serverscom-go-client/pkg" + "github.com/serverscom/srvctl/cmd/base" + "github.com/spf13/cobra" +) + +func newListCmd(cmdContext *base.CmdContext) *cobra.Command { + factory := func(verbose bool, args ...string) serverscom.Collection[serverscom.Rack] { + scClient := cmdContext.GetClient().SetVerbose(verbose).GetScClient() + return scClient.Racks.Collection() + } + + opts := base.NewListOptions( + &base.BaseListOptions[serverscom.Rack]{}, + &base.LabelSelectorOption[serverscom.Rack]{}, + ) + + return base.NewListCmd("list", "racks", factory, cmdContext, opts...) +} diff --git a/cmd/entities/racks/rack.go b/cmd/entities/racks/rack.go new file mode 100644 index 0000000..9d6a6f7 --- /dev/null +++ b/cmd/entities/racks/rack.go @@ -0,0 +1,39 @@ +package racks + +import ( + "log" + + serverscom "github.com/serverscom/serverscom-go-client/pkg" + "github.com/serverscom/srvctl/cmd/base" + "github.com/serverscom/srvctl/internal/output/entities" + "github.com/spf13/cobra" +) + +func NewCmd(cmdContext *base.CmdContext) *cobra.Command { + rackEntity, err := entities.Registry.GetEntityFromValue(serverscom.Rack{}) + if err != nil { + log.Fatal(err) + } + entitiesMap := make(map[string]entities.EntityInterface) + entitiesMap["racks"] = rackEntity + cmd := &cobra.Command{ + Use: "racks", + Short: "Manage private racks", + PersistentPreRunE: base.CombinePreRunE( + base.CheckFormatterFlags(cmdContext, entitiesMap), + base.CheckEmptyContexts(cmdContext), + ), + Args: base.NoArgs, + Run: base.UsageRun, + } + + cmd.AddCommand( + newListCmd(cmdContext), + newGetCmd(cmdContext), + newUpdateCmd(cmdContext), + ) + + base.AddFormatFlags(cmd) + + return cmd +} diff --git a/cmd/entities/racks/update.go b/cmd/entities/racks/update.go new file mode 100644 index 0000000..5591b7d --- /dev/null +++ b/cmd/entities/racks/update.go @@ -0,0 +1,54 @@ +package racks + +import ( + "log" + + serverscom "github.com/serverscom/serverscom-go-client/pkg" + "github.com/serverscom/srvctl/cmd/base" + "github.com/spf13/cobra" +) + +func newUpdateCmd(cmdContext *base.CmdContext) *cobra.Command { + var labels []string + + cmd := &cobra.Command{ + Use: "update ", + Short: "Update a private rack", + Long: "Update a private rack by id", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + manager := cmdContext.GetManager() + + ctx, cancel := base.SetupContext(cmd, manager) + defer cancel() + + base.SetupProxy(cmd, manager) + + labelsMap, err := base.ParseLabels(labels) + if err != nil { + log.Fatal(err) + } + input := serverscom.RackUpdateInput{ + Labels: labelsMap, + } + + scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient() + + id := args[0] + rack, err := scClient.Racks.Update(ctx, id, input) + if err != nil { + return err + } + + if rack != nil { + formatter := cmdContext.GetOrCreateFormatter(cmd) + return formatter.Format(rack) + } + return nil + }, + } + + cmd.Flags().StringArrayVarP(&labels, "label", "l", []string{}, "string in key=value format") + + return cmd +} diff --git a/cmd/root.go b/cmd/root.go index ab8051f..2dee630 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -6,6 +6,7 @@ import ( "github.com/serverscom/srvctl/cmd/context" "github.com/serverscom/srvctl/cmd/entities/hosts" loadbalancers "github.com/serverscom/srvctl/cmd/entities/load_balancers" + "github.com/serverscom/srvctl/cmd/entities/racks" sshkeys "github.com/serverscom/srvctl/cmd/entities/ssh-keys" "github.com/serverscom/srvctl/cmd/entities/ssl" "github.com/serverscom/srvctl/cmd/login" @@ -42,6 +43,7 @@ func NewRootCmd(version string) *cobra.Command { cmd.AddCommand(hosts.NewCmd(cmdContext)) cmd.AddCommand(ssl.NewCmd(cmdContext)) cmd.AddCommand(loadbalancers.NewCmd(cmdContext)) + cmd.AddCommand(racks.NewCmd(cmdContext)) return cmd } diff --git a/internal/output/entities/init.go b/internal/output/entities/init.go index 13aaf3d..d3cbd95 100644 --- a/internal/output/entities/init.go +++ b/internal/output/entities/init.go @@ -15,4 +15,5 @@ func init() { RegisterSSLCertCustomDefinition() RegisterSSLCertLeDefinition() RegisterLoadBalancerDefinitions() + RegisterRackDefinition() } diff --git a/internal/output/entities/rack.go b/internal/output/entities/rack.go new file mode 100644 index 0000000..039a48b --- /dev/null +++ b/internal/output/entities/rack.go @@ -0,0 +1,28 @@ +package entities + +import ( + "log" + "reflect" + + serverscom "github.com/serverscom/serverscom-go-client/pkg" +) + +var ( + RackType = reflect.TypeOf(serverscom.Rack{}) +) + +func RegisterRackDefinition() { + rackEntity := &Entity{ + fields: []Field{ + {ID: "ID", Name: "ID", Path: "ID", ListHandlerFunc: stringHandler, PageViewHandlerFunc: stringHandler, Default: true}, + {ID: "Name", Name: "Name", Path: "Name", ListHandlerFunc: stringHandler, PageViewHandlerFunc: stringHandler, Default: true}, + {ID: "LocationID", Name: "LocationID", Path: "LocationID", ListHandlerFunc: stringHandler, PageViewHandlerFunc: stringHandler, Default: true}, + {ID: "LocationCode", Name: "LocationCode", Path: "LocationCode", ListHandlerFunc: stringHandler, PageViewHandlerFunc: stringHandler, Default: true}, + {ID: "Labels", Name: "Labels", Path: "Labels", PageViewHandlerFunc: mapPvHandler}, + }, + eType: RackType, + } + if err := Registry.Register(rackEntity); err != nil { + log.Fatal(err) + } +} From 89628134547f81f1121b4ea182cc94ef6f644849 Mon Sep 17 00:00:00 2001 From: Oleg Isakov Date: Thu, 27 Mar 2025 15:18:34 +0200 Subject: [PATCH 2/2] add tests for racks cmd --- Makefile | 2 + cmd/entities/racks/list.go | 1 + cmd/entities/racks/{rack.go => racks.go} | 0 cmd/entities/racks/racks_test.go | 324 ++++++++++++++++++++++ internal/mocks/racks_service.go | 86 ++++++ testdata/entities/racks/get.json | 9 + testdata/entities/racks/get.txt | 2 + testdata/entities/racks/get.yaml | 6 + testdata/entities/racks/list.json | 11 + testdata/entities/racks/list_all.json | 20 ++ testdata/entities/racks/list_pageview.txt | 11 + testdata/entities/racks/list_template.txt | 2 + testdata/entities/racks/update.json | 9 + 13 files changed, 483 insertions(+) rename cmd/entities/racks/{rack.go => racks.go} (100%) create mode 100644 cmd/entities/racks/racks_test.go create mode 100644 internal/mocks/racks_service.go create mode 100644 testdata/entities/racks/get.json create mode 100644 testdata/entities/racks/get.txt create mode 100644 testdata/entities/racks/get.yaml create mode 100644 testdata/entities/racks/list.json create mode 100644 testdata/entities/racks/list_all.json create mode 100644 testdata/entities/racks/list_pageview.txt create mode 100644 testdata/entities/racks/list_template.txt create mode 100644 testdata/entities/racks/update.json diff --git a/Makefile b/Makefile index c7191fd..a9718c7 100644 --- a/Makefile +++ b/Makefile @@ -12,10 +12,12 @@ generate: deps mockgen --destination ./internal/mocks/ssh_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/ssh_keys.go mockgen --destination ./internal/mocks/ssl_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/ssl_certificates.go mockgen --destination ./internal/mocks/load_balancers_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/load_balancers.go + mockgen --destination ./internal/mocks/racks_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/racks.go sed -i '' 's|github.com/serverscom/srvctl/vendor/github.com/serverscom/serverscom-go-client/pkg|github.com/serverscom/serverscom-go-client/pkg|g' \ ./internal/mocks/ssh_service.go \ ./internal/mocks/hosts_service.go \ ./internal/mocks/ssl_service.go \ ./internal/mocks/load_balancers_service.go \ + ./internal/mocks/racks_service.go \ ./internal/mocks/collection.go diff --git a/cmd/entities/racks/list.go b/cmd/entities/racks/list.go index 78bf9f7..650ec50 100644 --- a/cmd/entities/racks/list.go +++ b/cmd/entities/racks/list.go @@ -15,6 +15,7 @@ func newListCmd(cmdContext *base.CmdContext) *cobra.Command { opts := base.NewListOptions( &base.BaseListOptions[serverscom.Rack]{}, &base.LabelSelectorOption[serverscom.Rack]{}, + &base.LocationIDOption[serverscom.Rack]{}, ) return base.NewListCmd("list", "racks", factory, cmdContext, opts...) diff --git a/cmd/entities/racks/rack.go b/cmd/entities/racks/racks.go similarity index 100% rename from cmd/entities/racks/rack.go rename to cmd/entities/racks/racks.go diff --git a/cmd/entities/racks/racks_test.go b/cmd/entities/racks/racks_test.go new file mode 100644 index 0000000..0849f54 --- /dev/null +++ b/cmd/entities/racks/racks_test.go @@ -0,0 +1,324 @@ +package racks + +import ( + "errors" + "path/filepath" + "testing" + + . "github.com/onsi/gomega" + serverscom "github.com/serverscom/serverscom-go-client/pkg" + "github.com/serverscom/srvctl/cmd/testutils" + "github.com/serverscom/srvctl/internal/mocks" + "go.uber.org/mock/gomock" +) + +var ( + testId = "testId" + fixtureBasePath = filepath.Join("..", "..", "..", "testdata", "entities", "racks") + testRack = serverscom.Rack{ + ID: testId, + Name: "test-rack", + LocationID: 1, + LocationCode: "test", + Labels: map[string]string{"foo": "bar"}, + } +) + +func TestGetRackCmd(t *testing.T) { + testCases := []struct { + name string + id string + output string + expectedOutput []byte + expectError bool + }{ + { + name: "get ssh key in default format", + id: testId, + output: "", + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "get.txt")), + }, + { + name: "get ssh key in JSON format", + id: testId, + output: "json", + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "get.json")), + }, + { + name: "get ssh key in YAML format", + id: testId, + output: "yaml", + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "get.yaml")), + }, + { + name: "get ssh key with error", + id: testId, + expectError: true, + }, + } + + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + racksServiceHandler := mocks.NewMockRacksService(mockCtrl) + + scClient := serverscom.NewClientWithEndpoint("", "") + scClient.Racks = racksServiceHandler + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + g := NewWithT(t) + + var err error + if tc.expectError { + err = errors.New("some error") + } + racksServiceHandler.EXPECT(). + Get(gomock.Any(), testId). + Return(&testRack, err) + + testCmdContext := testutils.NewTestCmdContext(scClient) + rackCmd := NewCmd(testCmdContext) + + args := []string{"racks", "get", tc.id} + if tc.output != "" { + args = append(args, "--output", tc.output) + } + + builder := testutils.NewTestCommandBuilder(). + WithCommand(rackCmd). + WithArgs(args) + + cmd := builder.Build() + + err = cmd.Execute() + + if tc.expectError { + g.Expect(err).To(HaveOccurred()) + } else { + g.Expect(err).To(BeNil()) + g.Expect(builder.GetOutput()).To(BeEquivalentTo(string(tc.expectedOutput))) + } + }) + } +} + +func TestListRacksCmd(t *testing.T) { + testRack1 := testRack + testRack2 := testRack + testRack1.ID += "1" + testRack2.Name = "test-rack 2" + testRack1.ID += "2" + + testCases := []struct { + name string + output string + args []string + expectedOutput []byte + expectError bool + configureMock func(*mocks.MockCollection[serverscom.Rack]) + }{ + { + name: "list all racks", + output: "json", + args: []string{"-A"}, + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "list_all.json")), + configureMock: func(mock *mocks.MockCollection[serverscom.Rack]) { + mock.EXPECT(). + Collect(gomock.Any()). + Return([]serverscom.Rack{ + testRack1, + testRack2, + }, nil) + }, + }, + { + name: "list racks", + output: "json", + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "list.json")), + configureMock: func(mock *mocks.MockCollection[serverscom.Rack]) { + mock.EXPECT(). + List(gomock.Any()). + Return([]serverscom.Rack{ + testRack1, + }, nil) + }, + }, + { + name: "list racks with template", + args: []string{"--template", "{{range .}}Name: {{.Name}}\n{{end}}"}, + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "list_template.txt")), + configureMock: func(mock *mocks.MockCollection[serverscom.Rack]) { + mock.EXPECT(). + List(gomock.Any()). + Return([]serverscom.Rack{ + testRack1, + testRack2, + }, nil) + }, + }, + { + name: "list racks with pageView", + args: []string{"--page-view"}, + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "list_pageview.txt")), + configureMock: func(mock *mocks.MockCollection[serverscom.Rack]) { + mock.EXPECT(). + List(gomock.Any()). + Return([]serverscom.Rack{ + testRack1, + testRack2, + }, nil) + }, + }, + { + name: "list racks with error", + expectError: true, + configureMock: func(mock *mocks.MockCollection[serverscom.Rack]) { + mock.EXPECT(). + List(gomock.Any()). + Return(nil, errors.New("some error")) + }, + }, + } + + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + racksServiceHandler := mocks.NewMockRacksService(mockCtrl) + collectionHandler := mocks.NewMockCollection[serverscom.Rack](mockCtrl) + + racksServiceHandler.EXPECT(). + Collection(). + Return(collectionHandler). + AnyTimes() + + collectionHandler.EXPECT(). + SetParam(gomock.Any(), gomock.Any()). + Return(collectionHandler). + AnyTimes() + + scClient := serverscom.NewClientWithEndpoint("", "") + scClient.Racks = racksServiceHandler + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + g := NewWithT(t) + + if tc.configureMock != nil { + tc.configureMock(collectionHandler) + } + + testCmdContext := testutils.NewTestCmdContext(scClient) + rackCmd := NewCmd(testCmdContext) + + args := []string{"racks", "list"} + if len(tc.args) > 0 { + args = append(args, tc.args...) + } + if tc.output != "" { + args = append(args, "--output", tc.output) + } + + builder := testutils.NewTestCommandBuilder(). + WithCommand(rackCmd). + WithArgs(args) + + cmd := builder.Build() + + err := cmd.Execute() + + if tc.expectError { + g.Expect(err).To(HaveOccurred()) + } else { + g.Expect(err).To(BeNil()) + g.Expect(builder.GetOutput()).To(BeEquivalentTo(string(tc.expectedOutput))) + } + }) + } +} + +func TestUpdateRackCmd(t *testing.T) { + newRack := testRack + newRack.Labels = map[string]string{"new": "label"} + + testCases := []struct { + name string + id string + output string + args []string + configureMock func(*mocks.MockRacksService) + expectedOutput []byte + expectError bool + }{ + { + name: "update rack", + id: testId, + output: "json", + expectedOutput: testutils.ReadFixture(filepath.Join(fixtureBasePath, "update.json")), + args: []string{"--label", "new=label"}, + configureMock: func(mock *mocks.MockRacksService) { + mock.EXPECT(). + Update(gomock.Any(), testId, serverscom.RackUpdateInput{ + Labels: map[string]string{"new": "label"}, + }). + Return(&newRack, nil) + }, + }, + { + name: "update rack with error", + id: testId, + configureMock: func(mock *mocks.MockRacksService) { + mock.EXPECT(). + Update(gomock.Any(), testId, serverscom.RackUpdateInput{ + Labels: make(map[string]string), + }). + Return(nil, errors.New("some error")) + }, + expectError: true, + }, + } + + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + racksServiceHandler := mocks.NewMockRacksService(mockCtrl) + + scClient := serverscom.NewClientWithEndpoint("", "") + scClient.Racks = racksServiceHandler + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + g := NewWithT(t) + + if tc.configureMock != nil { + tc.configureMock(racksServiceHandler) + } + + testCmdContext := testutils.NewTestCmdContext(scClient) + rackCmd := NewCmd(testCmdContext) + + args := []string{"racks", "update", tc.id} + if len(tc.args) > 0 { + args = append(args, tc.args...) + } + if tc.output != "" { + args = append(args, "--output", tc.output) + } + + builder := testutils.NewTestCommandBuilder(). + WithCommand(rackCmd). + WithArgs(args) + + cmd := builder.Build() + + err := cmd.Execute() + + if tc.expectError { + g.Expect(err).To(HaveOccurred()) + } else { + g.Expect(err).To(BeNil()) + g.Expect(builder.GetOutput()).To(BeEquivalentTo(string(tc.expectedOutput))) + } + }) + } +} diff --git a/internal/mocks/racks_service.go b/internal/mocks/racks_service.go new file mode 100644 index 0000000..d78f970 --- /dev/null +++ b/internal/mocks/racks_service.go @@ -0,0 +1,86 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./vendor/github.com/serverscom/serverscom-go-client/pkg/racks.go +// +// Generated by this command: +// +// mockgen --destination ./internal/mocks/racks_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/racks.go +// + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + serverscom "github.com/serverscom/serverscom-go-client/pkg" + gomock "go.uber.org/mock/gomock" +) + +// MockRacksService is a mock of RacksService interface. +type MockRacksService struct { + ctrl *gomock.Controller + recorder *MockRacksServiceMockRecorder + isgomock struct{} +} + +// MockRacksServiceMockRecorder is the mock recorder for MockRacksService. +type MockRacksServiceMockRecorder struct { + mock *MockRacksService +} + +// NewMockRacksService creates a new mock instance. +func NewMockRacksService(ctrl *gomock.Controller) *MockRacksService { + mock := &MockRacksService{ctrl: ctrl} + mock.recorder = &MockRacksServiceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRacksService) EXPECT() *MockRacksServiceMockRecorder { + return m.recorder +} + +// Collection mocks base method. +func (m *MockRacksService) Collection() serverscom.Collection[serverscom.Rack] { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Collection") + ret0, _ := ret[0].(serverscom.Collection[serverscom.Rack]) + return ret0 +} + +// Collection indicates an expected call of Collection. +func (mr *MockRacksServiceMockRecorder) Collection() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collection", reflect.TypeOf((*MockRacksService)(nil).Collection)) +} + +// Get mocks base method. +func (m *MockRacksService) Get(ctx context.Context, id string) (*serverscom.Rack, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", ctx, id) + ret0, _ := ret[0].(*serverscom.Rack) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockRacksServiceMockRecorder) Get(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRacksService)(nil).Get), ctx, id) +} + +// Update mocks base method. +func (m *MockRacksService) Update(ctx context.Context, id string, input serverscom.RackUpdateInput) (*serverscom.Rack, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Update", ctx, id, input) + ret0, _ := ret[0].(*serverscom.Rack) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Update indicates an expected call of Update. +func (mr *MockRacksServiceMockRecorder) Update(ctx, id, input any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRacksService)(nil).Update), ctx, id, input) +} diff --git a/testdata/entities/racks/get.json b/testdata/entities/racks/get.json new file mode 100644 index 0000000..4a81494 --- /dev/null +++ b/testdata/entities/racks/get.json @@ -0,0 +1,9 @@ +{ + "id": "testId", + "name": "test-rack", + "location_id": 1, + "location_code": "test", + "labels": { + "foo": "bar" + } +} \ No newline at end of file diff --git a/testdata/entities/racks/get.txt b/testdata/entities/racks/get.txt new file mode 100644 index 0000000..03e9092 --- /dev/null +++ b/testdata/entities/racks/get.txt @@ -0,0 +1,2 @@ +ID Name LocationID LocationCode +testId test-rack 1 test diff --git a/testdata/entities/racks/get.yaml b/testdata/entities/racks/get.yaml new file mode 100644 index 0000000..6ef9b3b --- /dev/null +++ b/testdata/entities/racks/get.yaml @@ -0,0 +1,6 @@ +id: testId +name: test-rack +locationid: 1 +locationcode: test +labels: + foo: bar diff --git a/testdata/entities/racks/list.json b/testdata/entities/racks/list.json new file mode 100644 index 0000000..f05963c --- /dev/null +++ b/testdata/entities/racks/list.json @@ -0,0 +1,11 @@ +[ + { + "id": "testId12", + "name": "test-rack", + "location_id": 1, + "location_code": "test", + "labels": { + "foo": "bar" + } + } +] \ No newline at end of file diff --git a/testdata/entities/racks/list_all.json b/testdata/entities/racks/list_all.json new file mode 100644 index 0000000..1ba13b2 --- /dev/null +++ b/testdata/entities/racks/list_all.json @@ -0,0 +1,20 @@ +[ + { + "id": "testId12", + "name": "test-rack", + "location_id": 1, + "location_code": "test", + "labels": { + "foo": "bar" + } + }, + { + "id": "testId", + "name": "test-rack 2", + "location_id": 1, + "location_code": "test", + "labels": { + "foo": "bar" + } + } +] \ No newline at end of file diff --git a/testdata/entities/racks/list_pageview.txt b/testdata/entities/racks/list_pageview.txt new file mode 100644 index 0000000..2e8a3c4 --- /dev/null +++ b/testdata/entities/racks/list_pageview.txt @@ -0,0 +1,11 @@ +ID: testId12 +Name: test-rack +LocationID: 1 +LocationCode: test +Labels: foo=bar +--- +ID: testId +Name: test-rack 2 +LocationID: 1 +LocationCode: test +Labels: foo=bar diff --git a/testdata/entities/racks/list_template.txt b/testdata/entities/racks/list_template.txt new file mode 100644 index 0000000..f3a5d21 --- /dev/null +++ b/testdata/entities/racks/list_template.txt @@ -0,0 +1,2 @@ +Name: test-rack +Name: test-rack 2 diff --git a/testdata/entities/racks/update.json b/testdata/entities/racks/update.json new file mode 100644 index 0000000..31324f5 --- /dev/null +++ b/testdata/entities/racks/update.json @@ -0,0 +1,9 @@ +{ + "id": "testId", + "name": "test-rack", + "location_id": 1, + "location_code": "test", + "labels": { + "new": "label" + } +} \ No newline at end of file