From 7920204640502ed3704f0779cce5037049fe3575 Mon Sep 17 00:00:00 2001 From: emonnin-epfl Date: Wed, 26 Jun 2024 15:12:00 +0200 Subject: [PATCH] change GetAllRumors to GetAllRumorParams --- be1-go/internal/database/sqlite/query.go | 19 ++- .../internal/database/sqlite/sqlite_test.go | 12 +- .../answer/hanswer/mocks/message_handler.go | 46 +++++++ .../handler/answer/hanswer/mocks/queries.go | 115 ++++++++++++++++++ .../answer/hanswer/mocks/rumor_handler.go | 52 ++++++++ .../rumorstate/hrumorstate/mocks/queries.go | 60 +++++++++ .../hrumorstate/mocks/repository.go | 88 ++++++++++++++ .../rumorstate/hrumorstate/mocks/sockets.go | 29 +++++ .../rumorstate/hrumorstate/rumorstate.go | 18 +-- .../rumorstate/hrumorstate/rumorstate_test.go | 20 +-- .../internal/network/socket/mocks/socket.go | 6 +- be1-go/internal/network/socket/socket.go | 2 +- be1-go/internal/network/socket/socket_impl.go | 11 +- 13 files changed, 436 insertions(+), 42 deletions(-) create mode 100644 be1-go/internal/handler/answer/hanswer/mocks/message_handler.go create mode 100644 be1-go/internal/handler/answer/hanswer/mocks/queries.go create mode 100644 be1-go/internal/handler/answer/hanswer/mocks/rumor_handler.go create mode 100644 be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/queries.go create mode 100644 be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/repository.go create mode 100644 be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/sockets.go diff --git a/be1-go/internal/database/sqlite/query.go b/be1-go/internal/database/sqlite/query.go index 60314fd677..0a96568777 100644 --- a/be1-go/internal/database/sqlite/query.go +++ b/be1-go/internal/database/sqlite/query.go @@ -379,6 +379,15 @@ func newRumor(rumorID int, sender string, messages map[string][]mmessage.Message } } +func newRumorParams(rumorID int, sender string, messages map[string][]mmessage.Message, timestamp mrumor.RumorTimestamp) mrumor.ParamsRumor { + return mrumor.ParamsRumor{ + RumorID: rumorID, + SenderID: sender, + Messages: messages, + Timestamp: timestamp, + } +} + func (s *SQLite) GetRumorTimestampHelper(tx *sql.Tx) (mrumor.RumorTimestamp, error) { rows, err := tx.Query(selectRumorState) @@ -441,7 +450,7 @@ func (s *SQLite) GetRumorTimestamp() (mrumor.RumorTimestamp, error) { return timestamp, nil } -func (s *SQLite) GetAllRumors() ([]mrumor.Rumor, error) { +func (s *SQLite) GetAllRumorParams() ([]mrumor.ParamsRumor, error) { dbLock.Lock() defer dbLock.Unlock() @@ -464,7 +473,7 @@ func (s *SQLite) GetAllRumors() ([]mrumor.Rumor, error) { } defer rows.Close() - rumors := make([]mrumor.Rumor, 0) + params := make([]mrumor.ParamsRumor, 0) for rows.Next() { var rumorID int var sender string @@ -484,15 +493,15 @@ func (s *SQLite) GetAllRumors() ([]mrumor.Rumor, error) { if err != nil { return nil, err } - rumor := newRumor(rumorID, sender, messages, timestamp) - rumors = append(rumors, rumor) + param := newRumorParams(rumorID, sender, messages, timestamp) + params = append(params, param) } if err = rows.Err(); err != nil { return nil, poperrors.NewDatabaseIteratorErrorMsg(err.Error()) } - return rumors, nil + return params, nil } func (s *SQLite) GetMessagesFromRumorHelper(tx *sql.Tx, rumorID int, sender string) (map[string][]mmessage.Message, error) { diff --git a/be1-go/internal/database/sqlite/sqlite_test.go b/be1-go/internal/database/sqlite/sqlite_test.go index b3e4292a26..a4fc93fed7 100644 --- a/be1-go/internal/database/sqlite/sqlite_test.go +++ b/be1-go/internal/database/sqlite/sqlite_test.go @@ -1098,10 +1098,10 @@ func Test_SQLite_GetAllRumors(t *testing.T) { err = lite.StoreFirstRumor() require.NoError(t, err) - rumors, err := lite.GetAllRumors() + params, err := lite.GetAllRumorParams() require.NoError(t, err) - require.Len(t, rumors, 0) + require.Len(t, params, 0) timestamp0 := make(mrumor.RumorTimestamp) timestamp0["sender1"] = 0 @@ -1114,10 +1114,10 @@ func Test_SQLite_GetAllRumors(t *testing.T) { timestamp1["sender2"] = 0 err = lite.StoreRumor(0, "sender2", timestamp1, nil, nil) - rumors, err = lite.GetAllRumors() + params, err = lite.GetAllRumorParams() require.NoError(t, err) - require.Len(t, rumors, 2) + require.Len(t, params, 2) msg1 := generator.NewNothingMsg(t, "client1", nil) err = lite.StoreMessageAndData("lao", msg1) @@ -1132,8 +1132,8 @@ func Test_SQLite_GetAllRumors(t *testing.T) { require.True(t, ok) require.Equal(t, map[string][]mmessage.Message{"lao": {msg1}}, rumor.Params.Messages) - rumors, err = lite.GetAllRumors() + params, err = lite.GetAllRumorParams() require.NoError(t, err) - require.Len(t, rumors, 3) + require.Len(t, params, 3) } diff --git a/be1-go/internal/handler/answer/hanswer/mocks/message_handler.go b/be1-go/internal/handler/answer/hanswer/mocks/message_handler.go new file mode 100644 index 0000000000..67a6540bc7 --- /dev/null +++ b/be1-go/internal/handler/answer/hanswer/mocks/message_handler.go @@ -0,0 +1,46 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import ( + mmessage "popstellar/internal/handler/message/mmessage" + + mock "github.com/stretchr/testify/mock" +) + +// MessageHandler is an autogenerated mock type for the MessageHandler type +type MessageHandler struct { + mock.Mock +} + +// Handle provides a mock function with given fields: channelPath, msg, fromRumor +func (_m *MessageHandler) Handle(channelPath string, msg mmessage.Message, fromRumor bool) error { + ret := _m.Called(channelPath, msg, fromRumor) + + if len(ret) == 0 { + panic("no return value specified for Handle") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, mmessage.Message, bool) error); ok { + r0 = rf(channelPath, msg, fromRumor) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMessageHandler creates a new instance of MessageHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMessageHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *MessageHandler { + mock := &MessageHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/answer/hanswer/mocks/queries.go b/be1-go/internal/handler/answer/hanswer/mocks/queries.go new file mode 100644 index 0000000000..740ef4605c --- /dev/null +++ b/be1-go/internal/handler/answer/hanswer/mocks/queries.go @@ -0,0 +1,115 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import ( + mrumor "popstellar/internal/handler/method/rumor/mrumor" + + mock "github.com/stretchr/testify/mock" +) + +// Queries is an autogenerated mock type for the Queries type +type Queries struct { + mock.Mock +} + +// GetRumor provides a mock function with given fields: queryID +func (_m *Queries) GetRumor(queryID int) (mrumor.Rumor, bool) { + ret := _m.Called(queryID) + + if len(ret) == 0 { + panic("no return value specified for GetRumor") + } + + var r0 mrumor.Rumor + var r1 bool + if rf, ok := ret.Get(0).(func(int) (mrumor.Rumor, bool)); ok { + return rf(queryID) + } + if rf, ok := ret.Get(0).(func(int) mrumor.Rumor); ok { + r0 = rf(queryID) + } else { + r0 = ret.Get(0).(mrumor.Rumor) + } + + if rf, ok := ret.Get(1).(func(int) bool); ok { + r1 = rf(queryID) + } else { + r1 = ret.Get(1).(bool) + } + + return r0, r1 +} + +// IsGetMessagesByID provides a mock function with given fields: id +func (_m *Queries) IsGetMessagesByID(id int) bool { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for IsGetMessagesByID") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(int) bool); ok { + r0 = rf(id) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// IsRumor provides a mock function with given fields: id +func (_m *Queries) IsRumor(id int) bool { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for IsRumor") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(int) bool); ok { + r0 = rf(id) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// IsRumorState provides a mock function with given fields: id +func (_m *Queries) IsRumorState(id int) bool { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for IsRumorState") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(int) bool); ok { + r0 = rf(id) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Remove provides a mock function with given fields: id +func (_m *Queries) Remove(id int) { + _m.Called(id) +} + +// NewQueries creates a new instance of Queries. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueries(t interface { + mock.TestingT + Cleanup(func()) +}) *Queries { + mock := &Queries{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/answer/hanswer/mocks/rumor_handler.go b/be1-go/internal/handler/answer/hanswer/mocks/rumor_handler.go new file mode 100644 index 0000000000..3b2bfda542 --- /dev/null +++ b/be1-go/internal/handler/answer/hanswer/mocks/rumor_handler.go @@ -0,0 +1,52 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import ( + mrumor "popstellar/internal/handler/method/rumor/mrumor" + socket "popstellar/internal/network/socket" + + mock "github.com/stretchr/testify/mock" +) + +// RumorHandler is an autogenerated mock type for the RumorHandler type +type RumorHandler struct { + mock.Mock +} + +// HandleRumorStateAnswer provides a mock function with given fields: _a0, rumor +func (_m *RumorHandler) HandleRumorStateAnswer(_a0 socket.Socket, rumor mrumor.ParamsRumor) error { + ret := _m.Called(_a0, rumor) + + if len(ret) == 0 { + panic("no return value specified for HandleRumorStateAnswer") + } + + var r0 error + if rf, ok := ret.Get(0).(func(socket.Socket, mrumor.ParamsRumor) error); ok { + r0 = rf(_a0, rumor) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SendRumor provides a mock function with given fields: _a0, rumor +func (_m *RumorHandler) SendRumor(_a0 socket.Socket, rumor mrumor.Rumor) { + _m.Called(_a0, rumor) +} + +// NewRumorHandler creates a new instance of RumorHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRumorHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *RumorHandler { + mock := &RumorHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/queries.go b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/queries.go new file mode 100644 index 0000000000..3eb68e9cdb --- /dev/null +++ b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/queries.go @@ -0,0 +1,60 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Queries is an autogenerated mock type for the Queries type +type Queries struct { + mock.Mock +} + +// AddRumorState provides a mock function with given fields: id +func (_m *Queries) AddRumorState(id int) error { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for AddRumorState") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int) error); ok { + r0 = rf(id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// GetNextID provides a mock function with given fields: +func (_m *Queries) GetNextID() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetNextID") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// NewQueries creates a new instance of Queries. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewQueries(t interface { + mock.TestingT + Cleanup(func()) +}) *Queries { + mock := &Queries{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/repository.go b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/repository.go new file mode 100644 index 0000000000..66c3faa47e --- /dev/null +++ b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/repository.go @@ -0,0 +1,88 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import ( + mrumor "popstellar/internal/handler/method/rumor/mrumor" + + mock "github.com/stretchr/testify/mock" +) + +// Repository is an autogenerated mock type for the Repository type +type Repository struct { + mock.Mock +} + +// GetAllRumorParams provides a mock function with given fields: +func (_m *Repository) GetAllRumorParams() ([]mrumor.ParamsRumor, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAllRumorParams") + } + + var r0 []mrumor.ParamsRumor + var r1 error + if rf, ok := ret.Get(0).(func() ([]mrumor.ParamsRumor, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []mrumor.ParamsRumor); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]mrumor.ParamsRumor) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GetRumorTimestamp provides a mock function with given fields: +func (_m *Repository) GetRumorTimestamp() (mrumor.RumorTimestamp, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetRumorTimestamp") + } + + var r0 mrumor.RumorTimestamp + var r1 error + if rf, ok := ret.Get(0).(func() (mrumor.RumorTimestamp, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() mrumor.RumorTimestamp); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(mrumor.RumorTimestamp) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewRepository creates a new instance of Repository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRepository(t interface { + mock.TestingT + Cleanup(func()) +}) *Repository { + mock := &Repository{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/sockets.go b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/sockets.go new file mode 100644 index 0000000000..6d1e0c670f --- /dev/null +++ b/be1-go/internal/handler/method/rumorstate/hrumorstate/mocks/sockets.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Sockets is an autogenerated mock type for the Sockets type +type Sockets struct { + mock.Mock +} + +// SendToRandom provides a mock function with given fields: buf +func (_m *Sockets) SendToRandom(buf []byte) { + _m.Called(buf) +} + +// NewSockets creates a new instance of Sockets. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewSockets(t interface { + mock.TestingT + Cleanup(func()) +}) *Sockets { + mock := &Sockets{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate.go b/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate.go index b35143f5da..be26c4c5b4 100644 --- a/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate.go +++ b/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate.go @@ -14,7 +14,7 @@ import ( type Repository interface { GetRumorTimestamp() (mrumor.RumorTimestamp, error) - GetAllRumors() ([]mrumor.Rumor, error) + GetAllRumorParams() ([]mrumor.ParamsRumor, error) } type Queries interface { @@ -49,24 +49,24 @@ func (h *Handler) Handle(socket socket.Socket, msg []byte) (*int, error) { return nil, errors.NewJsonUnmarshalError(err.Error()) } - myRumors, err := h.db.GetAllRumors() + myParams, err := h.db.GetAllRumorParams() if err != nil { return nil, err } - rumors := make([]mrumor.Rumor, 0) + params := make([]mrumor.ParamsRumor, 0) - for _, rumor := range myRumors { - if rumor.Params.Timestamp.IsBefore(rumorState.Params.State) || rumor.Params.Timestamp.IsEqual(rumorState.Params.State) { + for _, param := range myParams { + if param.Timestamp.IsBefore(rumorState.Params.State) || param.Timestamp.IsEqual(rumorState.Params.State) { continue } - rumors = append(rumors, rumor) + params = append(params, param) } - sort.Slice(rumors, func(i, j int) bool { - return rumors[i].Params.Timestamp.IsBefore(rumors[j].Params.Timestamp) + sort.Slice(params, func(i, j int) bool { + return params[i].Timestamp.IsBefore(params[j].Timestamp) }) - socket.SendRumorStateAnswer(rumorState.ID, rumors) + socket.SendRumorStateAnswer(rumorState.ID, params) return nil, nil } diff --git a/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate_test.go b/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate_test.go index 9d16b2daa2..0c6de476cc 100644 --- a/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate_test.go +++ b/be1-go/internal/handler/method/rumorstate/hrumorstate/rumorstate_test.go @@ -37,9 +37,9 @@ func Test_Handle(t *testing.T) { rumor2, _ := generator.NewRumorQuery(t, 2, sender2, 0, timestamp2, make(map[string][]mmessage.Message)) rumor3, _ := generator.NewRumorQuery(t, 3, sender1, 1, timestamp3, make(map[string][]mmessage.Message)) - rumors := []mrumor.Rumor{rumor3, rumor1, rumor2} + params := []mrumor.ParamsRumor{rumor3.Params, rumor1.Params, rumor2.Params} - db.On("GetAllRumors").Return(rumors, nil).Once() + db.On("GetAllRumorParams").Return(params, nil).Once() _, rumorStateBuf1 := generator.NewRumorStateQuery(t, 4, timestamp1) @@ -47,34 +47,34 @@ func Test_Handle(t *testing.T) { require.NoError(t, err) require.Nil(t, id) - expected := []mrumor.Rumor{rumor3, rumor2} + expected := []mrumor.ParamsRumor{rumor3.Params, rumor2.Params} require.Equal(t, fakeSocket.ResultID, 4) - require.Equal(t, expected, fakeSocket.Rumors) + require.Equal(t, expected, fakeSocket.RumorParams) - db.On("GetAllRumors").Return(rumors, nil).Once() + db.On("GetAllRumorParams").Return(params, nil).Once() _, rumorStateBuf2 := generator.NewRumorStateQuery(t, 4, timestamp2) id, err = rumorStateHandler.Handle(fakeSocket, rumorStateBuf2) require.NoError(t, err) require.Nil(t, id) - expected = []mrumor.Rumor{rumor1, rumor3} + expected = []mrumor.ParamsRumor{rumor1.Params, rumor3.Params} require.Equal(t, fakeSocket.ResultID, 4) - require.Equal(t, expected, fakeSocket.Rumors) + require.Equal(t, expected, fakeSocket.RumorParams) - db.On("GetAllRumors").Return(rumors, nil).Once() + db.On("GetAllRumorParams").Return(params, nil).Once() _, rumorStateBuf3 := generator.NewRumorStateQuery(t, 4, timestamp3) id, err = rumorStateHandler.Handle(fakeSocket, rumorStateBuf3) require.NoError(t, err) require.Nil(t, id) - expected = []mrumor.Rumor{rumor2} + expected = []mrumor.ParamsRumor{rumor2.Params} require.Equal(t, fakeSocket.ResultID, 4) - require.Equal(t, expected, fakeSocket.Rumors) + require.Equal(t, expected, fakeSocket.RumorParams) } diff --git a/be1-go/internal/network/socket/mocks/socket.go b/be1-go/internal/network/socket/mocks/socket.go index f11c1bc10e..91151dcf9e 100644 --- a/be1-go/internal/network/socket/mocks/socket.go +++ b/be1-go/internal/network/socket/mocks/socket.go @@ -23,7 +23,7 @@ type FakeSocket struct { Id string // the rumors present in a rumor state answer - Rumors []mrumor.Rumor + RumorParams []mrumor.ParamsRumor } func NewFakeSocket(ID string) *FakeSocket { @@ -56,8 +56,8 @@ func (f *FakeSocket) SendToRandom(buf []byte) { f.Msg = buf } -func (f *FakeSocket) SendRumorStateAnswer(id int, rumors []mrumor.Rumor) { - f.Rumors = rumors +func (f *FakeSocket) SendRumorStateAnswer(id int, params []mrumor.ParamsRumor) { + f.RumorParams = params f.ResultID = id } diff --git a/be1-go/internal/network/socket/socket.go b/be1-go/internal/network/socket/socket.go index 30551fe8bb..b5f5642f26 100644 --- a/be1-go/internal/network/socket/socket.go +++ b/be1-go/internal/network/socket/socket.go @@ -65,7 +65,7 @@ type Socket interface { SendResult(id int, res []mmessage.Message, missingMessagesByChannel map[string][]mmessage.Message) // SendRumorStateAnswer is used to send either an error or list of rumors to the sender - SendRumorStateAnswer(id int, rumors []mrumor.Rumor) + SendRumorStateAnswer(id int, params []mrumor.ParamsRumor) } // IncomingMessage wraps the raw message from the websocket connection and pairs diff --git a/be1-go/internal/network/socket/socket_impl.go b/be1-go/internal/network/socket/socket_impl.go index fb8b7639b8..de101b5723 100644 --- a/be1-go/internal/network/socket/socket_impl.go +++ b/be1-go/internal/network/socket/socket_impl.go @@ -268,10 +268,10 @@ func (s *baseSocket) SendResult(id int, res []mmessage.Message, missingMessagesB s.send <- answerBuf } -func (s *baseSocket) SendRumorStateAnswer(id int, rumors []mrumor.Rumor) { +func (s *baseSocket) SendRumorStateAnswer(id int, params []mrumor.ParamsRumor) { var answer interface{} - if rumors == nil { + if params == nil { answer = struct { JSONRPC string `json:"jsonrpc"` ID int `json:"id"` @@ -280,17 +280,12 @@ func (s *baseSocket) SendRumorStateAnswer(id int, rumors []mrumor.Rumor) { "2.0", id, 0, } } else { - result := make([]mrumor.ParamsRumor, 0) - for _, rumor := range rumors { - result = append(result, rumor.Params) - } - answer = struct { JSONRPC string `json:"jsonrpc"` ID int `json:"id"` Result []mrumor.ParamsRumor `json:"result"` }{ - "2.0", id, result, + "2.0", id, params, } }