diff --git a/packages/caliper-core/test/common/core/messages/assignedMessage.js b/packages/caliper-core/test/common/core/messages/assignedMessage.js new file mode 100644 index 000000000..229fe2321 --- /dev/null +++ b/packages/caliper-core/test/common/core/messages/assignedMessage.js @@ -0,0 +1,71 @@ +/* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +const AssignedMessage = require('../../../../lib/common/messages/assignedMessage'); +const MessageTypes = require('../../../../lib/common/utils/constants').Messages.Types; + +const chai = require('chai'); +chai.should(); + +describe('AssignedMessage', () => { + describe('Constructor', () => { + it('should create an AssignedMessage instance with sender, recipients, and type', () => { + const sender = 'John'; + const recipients = ['Alice', 'Bob']; + const message = new AssignedMessage(sender, recipients); + + message.should.be.an.instanceOf(AssignedMessage); + message.sender.should.equal(sender); + message.recipients.should.deep.equal(recipients); + message.type.should.equal(MessageTypes.Assigned); + }); + + it('should set the content of the message as an empty object', () => { + const message = new AssignedMessage('John', ['Alice', 'Bob']); + + message.content.should.deep.equal({}); + }); + + it('should parse the date argument as a Date object for the AssignedMessage', () => { + const date = '2024-04-25'; + const message = new AssignedMessage('John', ['Alice', 'Bob'], date); + + message.date.should.be.an.instanceOf(Date); + message.date + .toISOString() + .should.equal(new Date(date).toISOString()); + }); + + it('should set the error correctly if passed', () => { + const error = 'Some error'; + const message = new AssignedMessage( + 'John', + ['Alice', 'Bob'], + undefined, + error + ); + + message.error.should.equal(error); + }); + + it('should create an AssignedMessage with undefined date and error if not provided', () => { + const message = new AssignedMessage('John', ['Alice', 'Bob']); + + chai.expect(message.date).to.be.undefined; + chai.expect(message.error).to.be.undefined; + }); + }); +}); diff --git a/packages/caliper-core/test/common/core/messages/message.js b/packages/caliper-core/test/common/core/messages/message.js new file mode 100644 index 000000000..6b776cb37 --- /dev/null +++ b/packages/caliper-core/test/common/core/messages/message.js @@ -0,0 +1,146 @@ +/* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +const Message = require('../../../../lib/common/messages/message'); +const AllMessageTarget = require('../../../../lib/common/utils/constants').Messages.Targets.All + +const chai = require('chai'); +chai.should(); + +describe('Message', () => { + const mockSender = 'Test User'; + const mockRecipients = ["recepient-id-1", "recepient-id-2", "recepient-id-3"]; + const mockType = 'Assigned'; + const mockContent = { message: 'Hello' }; + const mockDate = '2024-04-25'; + const mockError = "Test Error"; + + describe("Constructor", () => { + it("should create a Message instance with sender, recipients, type, content, date, and error", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate, mockError); + + message.should.be.an.instanceOf(Message); + message.sender.should.equal(mockSender); + message.recipients.should.deep.equal(mockRecipients); + message.type.should.equal(mockType); + message.content.should.deep.equal(mockContent); + message.date.should.be.an.instanceOf(Date); + message.date.toISOString().should.equal(new Date(mockDate).toISOString()); + message.error.should.equal(mockError); + }); + + it("should set the date of the message as undefined not passed", () => { + const message = new Message(mockSender, mockRecipients, mockType); + + chai.expect(message.date).to.be.undefined; + }); + + it("should set the date of the message as an invalid Date object if the date is invalid", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, 'Invalid Date'); + + message.date.should.be.an.instanceOf(Date); + chai.expect(message.date.toString()).to.equal('Invalid Date'); + }) + }) + + describe("Getters", () => { + beforeEach(() => { + this.message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate, mockError); + }) + + it("should get the sender of the message", () => { + this.message.getSender().should.equal(mockSender); + }); + + it("should get the recipients of the message", () => { + this.message.getRecipients().should.deep.equal(mockRecipients); + }); + + it("should get the type of the message", () => { + this.message.getType().should.equal(mockType); + }); + + it("should get the content of the message", () => { + this.message.getContent().should.deep.equal(mockContent); + }); + }) + + describe("hasError", () => { + it("should return true if the message has an error", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate, mockError); + message.hasError().should.be.true; + }) + + it("should return false if the message has no error", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate); + message.hasError().should.be.false; + }) + }) + + describe("forRecipient", () => { + it("should return true if the message is for the recipient", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate); + + mockRecipients.forEach(recipient => { + message.forRecipient(recipient).should.be.true; + }) + }) + + it("should return true for all people if the message if for all", () => { + const message = new Message(mockSender, [AllMessageTarget], mockType, mockContent, mockDate); + + message.forRecipient(AllMessageTarget).should.be.true; + message.forRecipient('random-id').should.be.true; + }) + + it("should return false if the message is not for the recipient", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate); + + message.forRecipient('random-id').should.be.false; + }) + }) + + describe("stringify", () => { + it("should contain the date and the error if present", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate, mockError); + const stringifiedMessage = message.stringify(); + const decodedMessage = JSON.parse(stringifiedMessage); + + decodedMessage.sender.should.equal(mockSender); + decodedMessage.recipients.should.deep.equal(mockRecipients); + decodedMessage.type.should.equal(mockType); + decodedMessage.content.should.deep.equal(mockContent); + decodedMessage.date.should.equal(new Date(mockDate).toISOString()); + decodedMessage.error.should.equal(mockError); + }) + + it("should not include the error attribute if the message had no error", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent, mockDate); + const stringifiedMessage = message.stringify(); + const decodedMessage = JSON.parse(stringifiedMessage); + + chai.expect(decodedMessage.error).to.be.undefined; + }) + + it("should set the current date if the date is not provided", () => { + const message = new Message(mockSender, mockRecipients, mockType, mockContent); + const stringifiedMessage = message.stringify(); + const decodedMessage = JSON.parse(stringifiedMessage); + + decodedMessage.date.should.equal(new Date().toISOString()); + }) + }) +}) diff --git a/packages/caliper-core/test/common/core/messages/preparedMessage.js b/packages/caliper-core/test/common/core/messages/preparedMessage.js new file mode 100644 index 000000000..c199ed86f --- /dev/null +++ b/packages/caliper-core/test/common/core/messages/preparedMessage.js @@ -0,0 +1,71 @@ +/* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +const PreparedMessage = require('../../../../lib/common/messages/preparedMessage'); +const MessageTypes = require('../../../../lib/common/utils/constants').Messages.Types; + +const chai = require('chai'); +chai.should(); + +describe('PreparedMessage', () => { + describe('Constructor', () => { + it('should create an PreparedMessage instance with sender, recipients, and type', () => { + const sender = 'John'; + const recipients = ['Alice', 'Bob']; + const message = new PreparedMessage(sender, recipients); + + message.should.be.an.instanceOf(PreparedMessage); + message.sender.should.equal(sender); + message.recipients.should.deep.equal(recipients); + message.type.should.equal(MessageTypes.Prepared); + }); + + it('should set the content of the message as an empty object', () => { + const message = new PreparedMessage('John', ['Alice', 'Bob']); + + message.content.should.deep.equal({}); + }); + + it('should parse the date argument as a Date object for the PreparedMessage', () => { + const date = '2024-04-25'; + const message = new PreparedMessage('John', ['Alice', 'Bob'], date); + + message.date.should.be.an.instanceOf(Date); + message.date + .toISOString() + .should.equal(new Date(date).toISOString()); + }); + + it('should set the error correctly if passed', () => { + const error = 'Some error'; + const message = new PreparedMessage( + 'John', + ['Alice', 'Bob'], + undefined, + error + ); + + message.error.should.equal(error); + }); + + it('should create an PreparedMessage with undefined date and error if not provided', () => { + const message = new PreparedMessage('John', ['Alice', 'Bob']); + + chai.expect(message.date).to.be.undefined; + chai.expect(message.error).to.be.undefined; + }); + }); +}); diff --git a/packages/caliper-core/test/common/core/messages/readyMessage.js b/packages/caliper-core/test/common/core/messages/readyMessage.js new file mode 100644 index 000000000..f4077bca6 --- /dev/null +++ b/packages/caliper-core/test/common/core/messages/readyMessage.js @@ -0,0 +1,71 @@ +/* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +const ReadyMessage = require('../../../../lib/common/messages/readyMessage'); +const MessageTypes = require('../../../../lib/common/utils/constants').Messages.Types; + +const chai = require('chai'); +chai.should(); + +describe('ReadyMessage', () => { + describe('Constructor', () => { + it('should create an ReadyMessage instance with sender, recipients, and type', () => { + const sender = 'John'; + const recipients = ['Alice', 'Bob']; + const message = new ReadyMessage(sender, recipients); + + message.should.be.an.instanceOf(ReadyMessage); + message.sender.should.equal(sender); + message.recipients.should.deep.equal(recipients); + message.type.should.equal(MessageTypes.Ready); + }); + + it('should set the content of the message as an empty object', () => { + const message = new ReadyMessage('John', ['Alice', 'Bob']); + + message.content.should.deep.equal({}); + }); + + it('should parse the date argument as a Date object for the ReadyMessage', () => { + const date = '2024-04-25'; + const message = new ReadyMessage('John', ['Alice', 'Bob'], date); + + message.date.should.be.an.instanceOf(Date); + message.date + .toISOString() + .should.equal(new Date(date).toISOString()); + }); + + it('should set the error correctly if passed', () => { + const error = 'Some error'; + const message = new ReadyMessage( + 'John', + ['Alice', 'Bob'], + undefined, + error + ); + + message.error.should.equal(error); + }); + + it('should create an ReadyMessage with undefined date and error if not provided', () => { + const message = new ReadyMessage('John', ['Alice', 'Bob']); + + chai.expect(message.date).to.be.undefined; + chai.expect(message.error).to.be.undefined; + }); + }); +});