public void TestDeleteMessage()
        {
            foreach (var dataService in DataServices)
            {
                // Arrange.
                var recipient = new Client()
                {
                    ID = "recipientId"
                };
                var messageType = new MessageType()
                {
                    ID = "messageTypeId"
                };
                var message = new Message()
                {
                    Recipient = recipient, MessageType = messageType, ReceivingTime = DateTime.Now
                };
                var dataObjects = new DataObject[] { recipient, messageType, message };
                var component   = new TestBaseSendingManager(GetMockSubscriptionManager(), GetMockStatisticsService(), dataService, GetMockLogger());
                dataService.UpdateObjects(ref dataObjects);

                // Act & Assert.
                Assert.True(component.DeleteMessage(message.__PrimaryKey.ToString()));
            }
        }
        public void TestGetCurrentMessageCount()
        {
            foreach (var dataService in DataServices)
            {
                // Arrange.
                var recipient = new Client()
                {
                    ID = "recipientId"
                };
                var messageType = new MessageType()
                {
                    ID = "messageTypeId"
                };
                var secondMessageType = new MessageType()
                {
                    ID = "secondMessageTypeId"
                };
                var message = new Message()
                {
                    Recipient = recipient, MessageType = messageType, ReceivingTime = DateTime.Now
                };
                var secondMessage = new Message()
                {
                    Recipient = recipient, MessageType = secondMessageType, ReceivingTime = DateTime.Now
                };
                var dataObjects = new DataObject[] { recipient, messageType, secondMessageType, message, secondMessage };
                var component   = new TestBaseSendingManager(GetMockSubscriptionManager(), GetMockStatisticsService(), dataService, GetMockLogger());
                dataService.UpdateObjects(ref dataObjects);

                // Act & Assert.
                Assert.Equal(2, component.GetCurrentMessageCount(recipient.ID));
                Assert.Equal(1, component.GetCurrentMessageCount(recipient.ID, secondMessageType.ID));
            }
        }
        public void TestCheckEventIsRaised()
        {
            foreach (var dataService in DataServices)
            {
                // Arrange.
                var recipient = new Client()
                {
                    ID = "recipientId"
                };
                var eventType = new MessageType()
                {
                    ID = "eventTypeId"
                };
                var secondEventType = new MessageType()
                {
                    ID = "secondEventTypeId"
                };
                var neEvent = new Message()
                {
                    Recipient = recipient, MessageType = eventType, ReceivingTime = DateTime.Now
                };
                var dataObjects = new DataObject[] { recipient, eventType, secondEventType, neEvent };
                var component   = new TestBaseSendingManager(GetMockSubscriptionManager(), GetMockStatisticsService(), dataService, GetMockLogger());
                dataService.UpdateObjects(ref dataObjects);

                // Act & Assert.
                Assert.True(component.CheckEventIsRaised(recipient.ID, eventType.ID));
                Assert.False(component.CheckEventIsRaised(recipient.ID, secondEventType.ID));
            }
        }
        public void TestReadMessage()
        {
            foreach (var dataService in DataServices)
            {
                // Arrange.
                var recipientId             = "recipientId";
                var messageTypeId           = "messageTypeId";
                var message                 = InitReadMessageTestData(recipientId, messageTypeId, dataService)["ReadMessage"];
                var mockSubscriptionManager = new Mock <ISubscriptionsManager>();
                mockSubscriptionManager
                .Setup(sm => sm.GetSubscriptions(recipientId, true))
                .Returns(new[] { new Subscription()
                                 {
                                     MessageType = message.MessageType
                                 } });

                var component = new TestBaseSendingManager(mockSubscriptionManager.Object, GetMockStatisticsService(), dataService, GetMockLogger());

                // Act & Assert.
                Assert.Equal(message.__PrimaryKey, component.ReadMessage(message.__PrimaryKey.ToString()).__PrimaryKey);
            }
        }
        public void TestGetMessagesInfo()
        {
            foreach (var dataService in DataServices)
            {
                // Arrange.
                var now         = new DateTime(2000, 1, 1, 0, 0, 0);
                var random      = new Random().Next(5, 15);
                var dataObjects = new DataObject[random * 3];
                var recipient   = new Client()
                {
                    ID = "recipientId"
                };
                var messageType = new MessageType()
                {
                    ID = "messageTypeId"
                };
                var secondMessageType = new MessageType()
                {
                    ID = "secondMessageTypeId"
                };
                dataService.UpdateObject(recipient);
                dataService.UpdateObject(messageType);
                dataService.UpdateObject(secondMessageType);
                for (int i = 0; i < random; i++)
                {
                    dataObjects[i] = new Message()
                    {
                        Priority      = 1,
                        Recipient     = recipient,
                        MessageType   = secondMessageType,
                        ReceivingTime = now.AddYears(1),
                    };
                    dataObjects[i + random] = new Message()
                    {
                        Priority      = 2,
                        Group         = "group",
                        Recipient     = recipient,
                        MessageType   = messageType,
                        ReceivingTime = now.AddYears(2),
                    };
                    dataObjects[i + (random * 2)] = new Message()
                    {
                        Priority      = 3,
                        Recipient     = recipient,
                        MessageType   = messageType,
                        Tags          = "Color:Black;Name:Jack",
                        ReceivingTime = now.AddYears(3),
                    };
                }

                dataService.UpdateObjects(ref dataObjects);
                var component = new TestBaseSendingManager(GetMockSubscriptionManager(), GetMockStatisticsService(), dataService, GetMockLogger());

                // Act.
                var byClientId                                = component.GetMessagesInfo(recipient.ID);
                var byClientIdWithMax                         = component.GetMessagesInfo(recipient.ID, random);
                var byClientIdAndMessageTypeId                = component.GetMessagesInfo(recipient.ID, secondMessageType.ID);
                var byClientIdAndMessageTypeIdWithMax         = component.GetMessagesInfo(recipient.ID, secondMessageType.ID, random / 2);
                var byClientIdAndMessageTypeIdAndGroup        = component.GetMessagesInfo(recipient.ID, messageType.ID, "group");
                var byClientIdAndMessageTypeIdAndGroupWithMax = component.GetMessagesInfo(recipient.ID, messageType.ID, "group", random / 2);
                var byClientIdAndMessageTypeIdAndTags         = component.GetMessagesInfo(recipient.ID, messageType.ID, new[] { "Color", "Name" });
                var byClientIdAndMessageTypeIdAndTagsWithMax  = component.GetMessagesInfo(recipient.ID, messageType.ID, new[] { "Color", "Name" }, random / 2);

                // Assert.
                Assert.Equal(random * 3, byClientId.Length);
                Assert.Equal(random, byClientIdWithMax.Length);

                Assert.Equal(random, byClientIdAndMessageTypeId.Length);
                Assert.True(byClientIdAndMessageTypeId.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 1));
                Assert.True(byClientIdAndMessageTypeId.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == secondMessageType.ID));
                Assert.True(byClientIdAndMessageTypeId.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(1)));

                Assert.Equal(random / 2, byClientIdAndMessageTypeIdWithMax.Length);
                Assert.True(byClientIdAndMessageTypeIdWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 1));
                Assert.True(byClientIdAndMessageTypeIdWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == secondMessageType.ID));
                Assert.True(byClientIdAndMessageTypeIdWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(1)));

                Assert.Equal(random, byClientIdAndMessageTypeIdAndGroup.Length);
                Assert.True(byClientIdAndMessageTypeIdAndGroup.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 2));
                Assert.True(byClientIdAndMessageTypeIdAndGroup.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == messageType.ID));
                Assert.True(byClientIdAndMessageTypeIdAndGroup.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(2)));

                Assert.Equal(random / 2, byClientIdAndMessageTypeIdAndGroupWithMax.Length);
                Assert.True(byClientIdAndMessageTypeIdAndGroupWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 2));
                Assert.True(byClientIdAndMessageTypeIdAndGroupWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == messageType.ID));
                Assert.True(byClientIdAndMessageTypeIdAndGroupWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(2)));

                Assert.Equal(random, byClientIdAndMessageTypeIdAndTags.Length);
                Assert.True(byClientIdAndMessageTypeIdAndTags.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 3));
                Assert.True(byClientIdAndMessageTypeIdAndTags.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == messageType.ID));
                Assert.True(byClientIdAndMessageTypeIdAndTags.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(3)));

                Assert.Equal(random / 2, byClientIdAndMessageTypeIdAndTagsWithMax.Length);
                Assert.True(byClientIdAndMessageTypeIdAndTagsWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.Priority == 3));
                Assert.True(byClientIdAndMessageTypeIdAndTagsWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageTypeID == messageType.ID));
                Assert.True(byClientIdAndMessageTypeIdAndTagsWithMax.All <MessageInfoFromESB>(messageInfo => messageInfo.MessageFormingTime == now.AddYears(3)));
            }
        }