public void Method_Run_Should_Call_Succeedded_Event_When_Sending_Thrown_Exception()
{
var storage = new InMemoryReminderStorage();
storage.Add(DateTimeOffset.Now, null, null, ReminderItemStatus.Awaiting);
bool succeededEventCalled = false;
//создает класс содержащий интерфейс
var mockReceiver = new Mock <IReminderReceiver>();
var fakeReceiver = mockReceiver.Object;
using (var domain = new ReminderDomain(
storage,
fakeReceiver,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(50)))
{
domain.SendReminder += (reminder) => { };
domain.SendingSucceeded += (s, e) =>
{
succeededEventCalled = true;
};
domain.Run();
System.Threading.Thread.Sleep(1200);
}
Assert.IsTrue(succeededEventCalled);
}
public void When_Send_OK_SendingSucceededEvent_Raised()
{
var item = new ReminderItem {
Date = DateTimeOffset.Now
};
var storage = new InMemoryReminderStorage();
storage.Add(item);
var senderMock = new Mock <IReminderSender>(); //"заглушка", которая зависит от интерфейса, а не класса
using var domain = new ReminderDomain(
storage,
/*IReminderSender-объект-пустышка для тестирований*/ senderMock.Object,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromMilliseconds(10));
bool eventHandlerCalled = false;
domain.SendingSucceeded += (s, e) =>
{
eventHandlerCalled = true;
};
domain.Run();
Thread.Sleep(150);
Assert.IsTrue(eventHandlerCalled);
}
public void When_Send_ThrowException_FailEvent_Raised()
{
var item = new ReminderItem {
Date = DateTimeOffset.Now
};
var storage = new InMemoryReminderStorage();
storage.Add(item);
var senderMock = new Mock <IReminderSender>(); //"заглушка", которая зависит от интерфейса, а не класса
senderMock
.Setup(x => x.Send(It.IsAny <ReminderItem>())) //It.IsAny -- cоздаст любой объект
// .Callback(() => { });
.Throws(new Exception("Sending Failed Exception"));
using var domain = new ReminderDomain(
storage,
/*IReminderSender-объект-пустышка для тестирований*/ senderMock.Object,
TimeSpan.FromMilliseconds(10),
TimeSpan.FromMilliseconds(10));
bool eventHandlerCalled = false;
domain.SendingFailed += (s, e) =>
{
eventHandlerCalled = true;
};
domain.Run();
Thread.Sleep(150);
Assert.IsTrue(eventHandlerCalled);
}
public void Method_Get_By_Status_Should_Return_List_Of_Items_If_They_Exists()
{
// prepare test data
var expectedItem1 = new ReminderItem(DateTimeOffset.Now, "message 1", "ABCD123");
var expectedItem2 = new ReminderItem(DateTimeOffset.Now, "message 2", "ABCD123");
var expectedItem3 = new ReminderItem(DateTimeOffset.Now, "message 3", "ABCD123");
var expectedItem4 = new ReminderItem(DateTimeOffset.Now, "message 4", "ABCD123");
var storage = new InMemoryReminderStorage();
expectedItem2.Status = ReminderItemStatus.Ready;
expectedItem3.Status = ReminderItemStatus.Ready;
expectedItem4.Status = ReminderItemStatus.Failed;
storage.Reminders.Add(expectedItem1.Id, expectedItem1);
storage.Reminders.Add(expectedItem2.Id, expectedItem2);
storage.Reminders.Add(expectedItem3.Id, expectedItem3);
storage.Reminders.Add(expectedItem4.Id, expectedItem4);
// do test
var actualItemList = storage.Get(ReminderItemStatus.Ready);
// check results
Assert.IsNotNull(actualItemList);
Assert.AreEqual(2, actualItemList.Count);
Assert.IsTrue(actualItemList.Contains(expectedItem2));
Assert.IsTrue(actualItemList.Contains(expectedItem3));
}
public void When_Send_OK_SendingSucceeded_Event_Raised()
{
var item = new ReminderItem {
Date = DateTimeOffset.Now
};
var storage = new InMemoryReminderStorage();
storage.Add(item);
var senderMock = new Mock <IReminderSender>();
var receiverMock = new Mock <IReminderReceiver>();
using var domain = new ReminderDomain(
storage,
senderMock.Object /* IReminderSender */,
receiverMock.Object /* IReminderReceiver */,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(50));
bool eventHandlerCalled = false;
domain.SendingSucceeded += (s, e) =>
{
eventHandlerCalled = true;
};
domain.Run();
Thread.Sleep(150);
Assert.IsTrue(eventHandlerCalled);
}
public void AddMethodToStorage()
{
//prepare data
DateTimeOffset date = DateTimeOffset.Parse(
"2019-01-01T00:00:00");
const string contactId = "123qw";
const string message = "Позвони маме";
ReminderItem ri = new ReminderItem
(
date,
message,
contactId
);
InMemoryReminderStorage Storage = new InMemoryReminderStorage();
//do test
Storage.Add(ri);
//check result
//в хранилище есть нужная запись
Assert.IsTrue(Storage.Reminders.ContainsKey(ri.Id));
Assert.AreEqual(contactId, Storage.Reminders[ri.Id].ContactId);
Assert.AreEqual(date, Storage.Reminders[ri.Id].Date);
Assert.AreEqual(message, Storage.Reminders[ri.Id].Message);
Assert.AreEqual(ReminderItemStatus.Awating, Storage.Reminders[ri.Id].Status);
}
static void Main(string[] args)
{
const string token = "633428988:AAHLW_LaS7A47PDO2I8sbLkIIM9L0joPOSQ";
var storage = new InMemoryReminderStorage();
//var storage = new ReminderStorageWebApiClient("URL");
var sender = new TelegramReminderSender(token);
var receiver = new TelegramReminderReceiver(token);
using var domain = new ReminderDomain(
storage,
receiver,
sender,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1));
domain.SendingSucceeded += Domain_SendingSucceeded;
domain.SendingFailed += DomainOnSendingFailed;
domain.ParsingFailed += Domain_ParsingFailed;
domain.AddingSucceeded += Domain_AddingSucceeded;
domain.AddingFailed += Domain_AddingFailed;
domain.Run();
Console.WriteLine("Domain logic running... (press any key to exit)");
Console.ReadKey();
}
public void Method_Run_Should_Call_Failed_Event_When_Sending_Throw_Exception()
{
var storage = new InMemoryReminderStorage();
storage.Add(new ReminderItem(DateTimeOffset.Now, null, null));
bool failedEventCalled = false;
using (var domain = new ReminderDomain(storage, TimeSpan.FromMilliseconds(50), TimeSpan.FromSeconds(50)))
{
domain.SendReminder += (reminder) =>
{
throw new Exception("test exception");
};
domain.SendingFailed += (s, e) =>
{
if (e.SendingException.Message == "test exception")
{
failedEventCalled = true;
}
};
domain.Run();
System.Threading.Thread.Sleep(200);
}
var readyList = storage.Get(ReminderItemStatus.Ready);
Assert.IsNotNull(readyList);
Assert.AreEqual(1, storage.Get(ReminderItemStatus.Ready).Count);
}
public void Method_Run_Should_Call_Succeedded_Event_When_Sending_Thrown_Exception()
{
var storage = new InMemoryReminderStorage();
storage.Add(new ReminderItem(DateTimeOffset.Now, null, null));
bool succeededEventCalled = false;
using (var domain = new ReminderDomain(
storage,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(50)))
{
domain.SendReminder += (reminder) => { };
domain.SendingSucceeded += (s, e) =>
{
succeededEventCalled = true;
};
domain.Run();
System.Threading.Thread.Sleep(1200);
}
Assert.IsTrue(succeededEventCalled);
}
public void Get_List_Of_Objects_With_Statuses_ReadyToSend_And_Failed()
{
var reminder = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
var reminder1 = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
var reminder2 = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
var reminder3 = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
reminder3.Status = ReminderItemStatus.ReadyToSend;
var reminder4 = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
reminder4.Status = ReminderItemStatus.ReadyToSend;
var reminder5 = new ReminderItem(DateTimeOffset.Now, "Hello!", "New ID");
reminder5.Status = ReminderItemStatus.Failed;
var testStorage = new InMemoryReminderStorage();
var statuses = new List <ReminderItemStatus>();
testStorage.Add(reminder);
testStorage.Add(reminder1);
testStorage.Add(reminder2);
testStorage.Add(reminder3);
testStorage.Add(reminder4);
testStorage.Add(reminder5);
statuses.Add(ReminderItemStatus.ReadyToSend);
statuses.Add(ReminderItemStatus.Failed);
var listOfItemsFromStorage = testStorage.GetList(statuses);
Assert.IsNotNull(listOfItemsFromStorage);
Assert.IsFalse(listOfItemsFromStorage.Contains(reminder));
Assert.IsFalse(listOfItemsFromStorage.Contains(reminder1));
Assert.IsFalse(listOfItemsFromStorage.Contains(reminder2));
Assert.IsTrue(listOfItemsFromStorage.Contains(reminder3));
Assert.IsTrue(listOfItemsFromStorage.Contains(reminder4));
Assert.IsTrue(listOfItemsFromStorage.Contains(reminder5));
}
public void Call_FailedEvent()
{
//var item = new ReminderItem();
var storage = new InMemoryReminderStorage();
storage.Add(new ReminderItem(DateTimeOffset.Now, null, null));
bool failedEventCalled = false;
using (var domain = new ReminderDomain(
storage,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(50)))
{
//т.к. таймеры в домене отрабатывают раз в секунду, надо подождать пару секунд
domain.SendReminder += (r) =>
{
throw new Exception("Тестовое исключение");
};
domain.SendingFailed += (s, e) =>
{
if (e.SendingException.Message == "Тестовое исключение")
{
failedEventCalled = true;
}
};
domain.Run();
System.Threading.Thread.Sleep(1200);
}
//проверки
Assert.IsTrue(failedEventCalled);
}
public void Awaiting_Item_Changes_Status_to_ReadyToSend_After_Checking_Period()
{
var storage = new InMemoryReminderStorage();
using var domain = new ReminderDomain(
storage,
TimeSpan.FromMilliseconds(50));
var item = new ReminderItem(
DateTimeOffset.Now,
"Hello world",
"testContact007");
domain.AddReminder(item);
// run
domain.Run();
// check the results
System.Threading.Thread.Sleep(50);
var actualItem = storage.Get(item.Id);
Assert.IsNotNull(actualItem);
Assert.AreEqual(ReminderItemStatus.ReadyToSend, actualItem.Status);
}
public void Method_Add_Should_Add_New_Item_To_Internal_Dictionary()
{
// prepare test data
InMemoryReminderStorage inMemoryReminderStorage = new InMemoryReminderStorage();
DateTimeOffset date = DateTimeOffset.Parse(
"2010-01-01T00:00:00");
const string contactId = "0123ABC";
const string message = "Test message";
// do test
var reminderItem = new ReminderItem(
date, message, contactId);
inMemoryReminderStorage.Add(reminderItem);
// check results
Assert.IsTrue(inMemoryReminderStorage.Reminders.ContainsKey(reminderItem.Id));
Assert.AreEqual(message, inMemoryReminderStorage.Reminders[reminderItem.Id].Message);
Assert.AreEqual(date, inMemoryReminderStorage.Reminders[reminderItem.Id].Date);
Assert.AreEqual(contactId, inMemoryReminderStorage.Reminders[reminderItem.Id].ContactId);
}
public void Method_Update_Is_Working()
{
// prepare test data
InMemoryReminderStorage inMemoryReminderStorage = new InMemoryReminderStorage();
DateTimeOffset date = DateTimeOffset.Parse(
"2010-01-01T00:00:00");
const string contactId = "0123ABC";
const string message = "Test message";
// do test
var reminderItem = new ReminderItem(
date, message, contactId);
inMemoryReminderStorage.Add(reminderItem);
inMemoryReminderStorage.Update(reminderItem.Id, ReminderItemStatus.Ready);
// check results
Assert.AreEqual(reminderItem.Status, ReminderItemStatus.Ready);
}
public void Method_Get_should_return_list_of_reminders_by_status()
{
var storage = new InMemoryReminderStorage();
ReminderItem item = new ReminderItem(
DateTimeOffset.Parse("2019-01-01T00:00:00+00:00"),
"test message",
"ABCD123"
)
{
Status = ReminderItemStatus.Ready
};
storage.Add(item);
ReminderItem item2 = new ReminderItem(
DateTimeOffset.Parse("2019-01-02T00:00:00+00:00"),
"test message2",
"ABCD456"
)
{
Status = ReminderItemStatus.Ready
};
storage.Add(item2);
ReminderItem item3 = new ReminderItem(
DateTimeOffset.Parse("2019-01-02T00:00:00+00:00"),
"test message2",
"ABCD456"
)
{
Status = ReminderItemStatus.Failed
};
storage.Add(item3);
//do
List <ReminderItem> resReady = storage.Get(ReminderItemStatus.Ready);
List <ReminderItem> resFailed = storage.Get(ReminderItemStatus.Failed);
List <ReminderItem> resAwating = storage.Get(ReminderItemStatus.Awating);
List <ReminderItem> resSent = storage.Get(ReminderItemStatus.Sent);
//
foreach (ReminderItem ri in resReady)
{
Assert.AreEqual(ri.Status, ReminderItemStatus.Ready);
}
foreach (ReminderItem ri in resFailed)
{
Assert.AreEqual(ri.Status, ReminderItemStatus.Failed);
}
Assert.AreEqual(resReady.Count, 2);
Assert.AreEqual(resFailed.Count, 1);
Assert.AreEqual(resAwating.Count, 0);
Assert.AreEqual(resSent.Count, 0);
}
public void Method_Run_Should_Call_SendReminder_Method_For_Particular_Item()
{
var storage = new InMemoryReminderStorage();
storage.Add(new ReminderItem(DateTimeOffset.Now, "test message", null));
bool sendReminderDelegateCalled = false;
using (var domain = new ReminderDomain(
storage,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(50)))
{
domain.SendReminder += (ReminderItem r) =>
{
if (r.Message == "test message")
{
sendReminderDelegateCalled = true;
}
};
domain.Run();
System.Threading.Thread.Sleep(1200);
}
Assert.IsTrue(sendReminderDelegateCalled);
}
public void Awaiting_Item_Changes_Status_To_ReadyToSend_After_Checking_Period()
{
//preparing
var storage = new InMemoryReminderStorage();
var sender = new TelegramReminderSender("1467408776:AAGSGszyTCYYCTWTKu4PL_it029uC8X8hbs");
var receiver = new TelegramReminderReceiver("1467408776:AAGSGszyTCYYCTWTKu4PL_it029uC8X8hbs");
using var domain = new ReminderDomain(storage, receiver, sender, TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(50));
var item = new ReminderItem(DateTimeOffset.Now, "Hello World!", "TestContact"); //addReminderModel
//domain.AddReminder(item); //Model was here
// run
domain.Run();
//Check the result
System.Threading.Thread.Sleep(50);
var actualItem = storage.Get(item.Id);
Assert.IsNotNull(actualItem);
Assert.AreEqual(ReminderItemStatus.ReadyToSend, actualItem.Status);
}
public void Check_That_Reminder_Calls_Internal_Delegate()
{
var reminderStorage = new InMemoryReminderStorage();
using (var reminderDomain = new ReminderDomain(
reminderStorage,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(100)))
{
bool delegateWasCalled = false;
reminderDomain.SendReminder += (reminder) =>
{
delegateWasCalled = true;
};
reminderDomain.AddReminder(
new AddReminderModel
{
Date = DateTimeOffset.Now
});
reminderDomain.Run();
Thread.Sleep(300);
Assert.IsTrue(delegateWasCalled);
}
}
public void GetMethodFromStorage()
{
//prepare data
DateTimeOffset date = DateTimeOffset.Parse("2019-01-01T00:00:00");
const string contactId = "1f23qw";
const string message = "Позвони папе";
ReminderItem ri = new ReminderItem
(
date,
message,
contactId
);
InMemoryReminderStorage Storage = new InMemoryReminderStorage();
Storage.Reminders.Add(ri.Id, ri);
//do test
ReminderItem item = Storage.Get(ri.Id);
ReminderItem item2 = Storage.Get(Guid.Empty);
//check result
//null если нет такого guid в хранилище
Assert.IsNull(item2);
//в хранилище то что надо
Assert.AreEqual(date, item.Date);
Assert.AreEqual(contactId, item.ContactId);
Assert.AreEqual(message, item.Message);
}
public void Check_That_On_SendReminder_OK_SendingSuccedded_Event_Raised()
{
var reminderStorage = new InMemoryReminderStorage();
using (var reminderDomain = new ReminderDomain(
reminderStorage,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(100)))
{
bool eventHandlerCalled = false;
reminderDomain.SendingSucceded += (s, e) =>
{
eventHandlerCalled = true;
};
reminderDomain.AddReminder(
new AddReminderModel
{
Date = DateTimeOffset.Now
});
reminderDomain.Run();
Thread.Sleep(300);
Assert.IsTrue(eventHandlerCalled);
}
}
public void Method_Run_Should_Failed_Event_When_Sending_Thrown_Exception()
{
var storage = new InMemoryReminderStorage();
storage.Add(new ReminderItem(DateTimeOffset.Now, null, null));
bool failedEventCalled = false;
using (var domain = new ReminderDomain(
storage,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(50)))
{
//do test
domain.Run();
domain.SendReminder += (reminder) =>
{
throw new Exception("test Exception");
};
domain.SendingFailed += (s, e) =>
{
if (e.SendingException.Message == "test exception")
{
failedEventCalled = true;
}
};
Thread.Sleep(1200);
}
//check result
Assert.IsTrue(failedEventCalled);
}
public void Get_Add_Of_Item_With_Already_Added_Id_Throws_Exception()
{
var guid = new Guid();
guid = Guid.NewGuid();
var reminderItem1 = new ReminderItem(
guid,
DateTimeOffset.Now,
"1",
"1",
ReminderItemStatus.Failed);
var reminderItem2 = new ReminderItem(
guid,
DateTimeOffset.Now,
"2",
"2",
ReminderItemStatus.Failed);
var storage = new InMemoryReminderStorage();
storage.Add(reminderItem1);
Assert.ThrowsException <ArgumentException>(() =>
{
try
{
storage.Add(reminderItem2);
}
catch (ArgumentException e)
{
return;
}
throw new ArgumentException();
});
}
public void When_SendReminder_OK_SendingSuccedded_Event_Raised()
{
var reminderStorage = new InMemoryReminderStorage();
using (var reminderDomain = new ReminderDomain(
reminderStorage,
receiverMock.Object,
senderMock.Object,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(100)))
{
bool eventHandlerCalled = false;
reminderDomain.SendingSucceded += (s, e) =>
{
eventHandlerCalled = true;
};
reminderStorage.Add(new Storage.Core.ReminderItem
{
Date = DateTimeOffset.Now
});
reminderDomain.Run();
Thread.Sleep(300);
Assert.IsTrue(eventHandlerCalled);
}
}
static void Main(string[] args)
{
Console.WriteLine("Telegram Bot Application!");
var storage = new InMemoryReminderStorage();
var domain = new ReminderDomain(storage);
IWebProxy proxy = new HttpToSocks5Proxy("proxy.golyakov.net", 1080);
string token = "874002335:AAHCWlQVHGvM6if784HJ0rHTfcUg7SbSR5s";
var sender = new TelegramReminderSender(token, proxy);
var receiver = new TelegramReminderReceiver(token, proxy);
receiver.MessageReceived += (s, e) =>
{
Console.WriteLine($"Message from contact '{e.ContactId}' with text '{e.Message}'");
//add new reminderitem to the storage
var parsedMessage = MessageParser.Parse(e.Message);
var item = new ReminderItem(parsedMessage.Date, parsedMessage.Message, e.ContactId);
storage.Add(item);
};
receiver.Run();
domain.SendReminder = (ReminderItem ri) =>
{
sender.Send(ri.ContactId, ri.Message);
};
domain.Run();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Telegram Bot Application!");
var storage = new InMemoryReminderStorage();
string token = "633428988:AAHLW_LaS7A47PDO2I8sbLkIIM9L0joPOSQ";
IWebProxy proxy = new HttpToSocks5Proxy(
"proxy.golyakov.net", 1080);
var receiver = new TelegramReminderReceiver(token, proxy);
var domain = new ReminderDomain(storage, receiver);
var sender = new TelegramReminderSender(token, proxy);
domain.SendReminder = (ReminderItem ri) =>
{
sender.Send(ri.ContactId, ri.Message);
};
domain.MessageReceived += Domain_MessageReceived;
domain.MessageParsingSuccedded += Domain_MessageParsingSuccedded;
domain.MessageParsingFailed += Domain_MessageParsingFailed;
domain.AddingToStorageSuccedded += Domain_AddingToStorageSuccedded;
domain.AddingToStorageFailed += Domain_AddingToStorageFailed;
domain.Run();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public void Method_Run_Should_Update_Ready_To_Send_Reminders_To_Status_Ready_From_Awiating()
{
var storage = new InMemoryReminderStorage();
storage.Add(DateTimeOffset.Now, null, null, ReminderItemStatus.Awaiting);
//создает класс содержащий интерфейс
var mockReceiver = new Mock <IReminderReceiver>();
var fakeReceiver = mockReceiver.Object;
using (var domain = new ReminderDomain(
storage,
fakeReceiver,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromSeconds(1)))
{
domain.Run();
System.Threading.Thread.Sleep(200);
}
var readyList = storage.Get(ReminderItemStatus.Ready);
Assert.IsNotNull(readyList);
Assert.AreEqual(1, readyList.Count);
}
public void Update_Updates_All_Properties_Of_ReminderItem_With_Given_Id_If_It_Exists()
{
var original = new ReminderItem
{
Id = Guid.Parse("00000000-0000-0000-0000-111111111111"),
Date = DateTimeOffset.Parse("2001-01-01 01:01:01+0000"),
Message = "Awaiting",
ContactId = "1",
Status = ReminderItemStatus.Awaiting
};
var updated = new ReminderItem
{
Id = Guid.Parse("00000000-0000-0000-0000-111111111111"),
Date = DateTimeOffset.Parse("2002-02-02 02:02:02+0000"),
Message = "ReadyToSend",
ContactId = "2",
Status = ReminderItemStatus.ReadyToSend
};
var storage = new InMemoryReminderStorage();
storage.Add(original);
storage.Update(updated);
var actual = storage.Get(Guid.Parse("00000000-0000-0000-0000-111111111111"));
Assert.IsNotNull(actual);
Assert.AreEqual(updated.Id, actual.Id);
Assert.AreEqual(updated.Date, actual.Date);
Assert.AreEqual(updated.Message, actual.Message);
Assert.AreEqual(updated.ContactId, actual.ContactId);
Assert.AreEqual(updated.Status, actual.Status);
}
public void Get_Returns_Just_Added_Item()
{
Guid guid = Guid.NewGuid();
DateTimeOffset date = DateTimeOffset.Now;
string message = "TEST MESSAGE";
string contactId = "TEST ID 123";
ReminderItemStatus status = ReminderItemStatus.Failed;
var expected = new ReminderItem(guid, date, message, contactId, status);
var storage = new InMemoryReminderStorage();
// test action
storage.Add(expected);
var actual = storage.Get(guid);
// check results
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Date, actual.Date);
Assert.AreEqual(expected.ContactId, actual.ContactId);
Assert.AreEqual(expected.Message, actual.Message);
Assert.AreEqual(expected.Status, actual.Status);
}
public void GetList_Does_Not_Return_Null_If_No_Items_Found()
{
var storage = new InMemoryReminderStorage();
var actual = storage.GetList(ReminderItemStatus.Awaiting);
Assert.IsNotNull(actual);
}
public void Update_Throws_InvalidOperationException_If_ReminderItem_With_Given_Id_Does_Not_Exist()
{
var storage = new InMemoryReminderStorage();
var itemToUpdate = new ReminderItem();
Assert.ThrowsException <InvalidOperationException>(() => storage.Update(itemToUpdate));
}
