public MicrowaveOven GetCheapestAPlusMicrowaveOven()
{
var cheapestMicrowaveOven = new MicrowaveOven();
foreach (var microwaveOven in MicrowaveOvens)
{
if (microwaveOven.EnergyClass == "A+")
{
cheapestMicrowaveOven = microwaveOven;
break;
}
}
if (cheapestMicrowaveOven.Price == 0)
{
return(null);
}
foreach (var microwaveOven in MicrowaveOvens)
{
if (microwaveOven.EnergyClass == "A+" && microwaveOven.Price < cheapestMicrowaveOven.Price)
{
cheapestMicrowaveOven = microwaveOven;
}
}
return(cheapestMicrowaveOven);
}
public static void Main()
{
IMessage tweet = new Tweet("test msg");
IWriter console = new ConsoleWriter();
IClient microwave = new MicrowaveOven(console);
microwave.RetrieveMessage(tweet);
}
public void Init()
{
this.fakeConsole = new FakeConsole();
this.fakeServer = new FakeServer();
this.oven = new MicrowaveOven(fakeServer, fakeConsole);
this.defaultTweet = new Tweet(oven);
defaultTweet.RetrieveMessage("Hello world!");
}
public void ClientShouldSendMessageToServerAfterReceivingTweet()
{
Tweet tweet = Mock.Of <Tweet>();
MicrowaveOven client = Mock.Of <MicrowaveOven>();
client.ReceiveTweet(tweet);
Mock.Get(client).Verify(x =>
x.SendMessageToServer(It.IsAny <string>()), Times.Once);
}
public bool Equals(MicrowaveOven other)
{
return(Manufacturer == other.Manufacturer &&
Model == other.Model &&
EnergyClass == other.EnergyClass &&
Color == other.Color &&
Price == other.Price &&
Power == other.Power &&
ProgramCount == other.ProgramCount);
}
static void Main(string[] args)
{
var console = new ConsoleWrapper();
var server = new Server();
var oven = new MicrowaveOven(server, console);
var tweet = new Tweet(oven);
tweet.RetrieveMessage("Hello world!");
}
public void TestMicrowaveOven_WriteMessageMethod()
{
Mock <IWriter> writer = new Mock <IWriter>();
Mock <IRepository> repo = new Mock <IRepository>();
IClient microwave = new MicrowaveOven(writer.Object, repo.Object);
microwave.WriteMessage(Msg);
writer.Verify(w => w.WriteLine(It.Is <string>(s => s == Msg)), Times.Once, "Message hasn't been sent!");
}
public void TestMicrowaveOven_ArchiveMessageMethod()
{
Mock <IWriter> writer = new Mock <IWriter>();
Mock <IRepository> repo = new Mock <IRepository>();
IClient microwave = new MicrowaveOven(writer.Object, repo.Object);
microwave.ArchiveMessageInServer(Msg);
repo.Verify(x => x.ArchiveMessage(It.Is <string>(s => s == Msg)), Times.Once, "The given message was not stored in the repository");
}
public void WriteTweetShouldCallItsWriterWithTheTweetsMessage()
{
var writer = new Mock <IWriter>();
writer.Setup(w => w.WriteLine(It.IsAny <string>()));
var tweetRepo = new Mock <IServer>();
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
microwaveOven.WriteTweet("tui tuk");
writer.Verify(w => w.WriteLine(It.Is <string>(s => s == "tui tuk")));
}
public void MicrowaveInvokesItsWriterToWriteMessages()
{
var writer = new Mock <IWriter>();
writer.Setup(w => w.WriteLine(It.IsAny <string>()));
var microwaveOven = new MicrowaveOven(writer.Object, repository);
microwaveOven.WriteTweet(Message);
writer.Verify(w => w.WriteLine(It.Is <string>(s => s == Message)), Times.Once, "Microwave did not invoke its writer");
}
public void SendTweetToServerShouldSendTheMessageToItsServer()
{
var writer = new Mock <IWriter>();
var tweetRepo = new Mock <IServer>();
tweetRepo.Setup(tr => tr.SaveTweet(It.IsAny <string>()));
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
microwaveOven.SendTweetToServer("tui tuk");
tweetRepo.Verify(tr => tr.SaveTweet(It.Is <string>(s => s == "tui tuk")),
Times.Once);
}
public void TestWriteMessage()
{
var writer = new Mock <IWriter>();
var tweetRepo = new Mock <ITweetRepository>();
writer.Setup(p => p.Print(It.IsAny <string>()));
var oven = new MicrowaveOven(writer.Object, tweetRepo.Object);
oven.WriteTweet(tweet);
writer.Verify(p => p.Print(It.Is <string>(k => k == tweet)),
"Tweet does not displayed on the Cosole");
}
public void MicrowaveShouldInvokeItsRepositoryToSendMessagesToServer()
{
var repo = new Mock <ITweetRepository>();
repo.Setup(r => r.SaveTweet(It.IsAny <string>()));
var microwaveOven = new MicrowaveOven(writer, repo.Object);
microwaveOven.SendTweetToServer(Message);
repo.Verify(r => r.SaveTweet(It.IsAny <string>()), Times.Once, "Microwave did not invoke its Repository");
}
public void WriteTweetShouldCallItsWriterWithTheTweetsMessage()
{
var writer = new Mock <IWriter>();
writer.Setup(w => w.WriteLine(It.IsAny <string>()));
var tweetRepo = new Mock <ITweetRepository>();
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
microwaveOven.WriteTweet(Message);
writer.Verify(w => w.WriteLine(It.Is <string>(s => s == Message)),
$"Tweet is not given to the {typeof(MicrowaveOven)}'s writer");
}
public void MicrowaveMethodSendTweetToServerShouldCreateAServerFile()
{
var microwaveOven = new MicrowaveOven(writer, repository);
microwaveOven.SendTweetToServer(Message);
FileAssert.Exists(filePath);
string[] serverFileContents = File.ReadLines(filePath).ToArray();
Assert.IsTrue(serverFileContents.ToString().Length > 0);
Assert.Contains(Message, serverFileContents);
}
public void TestSendMessageToServer()
{
var writer = new Mock <IWriter>();
var tweetRepo = new Mock <ITweetRepository>();
tweetRepo.Setup(p => p.SaveTweet(It.IsAny <string>()));
var oven = new MicrowaveOven(writer.Object, tweetRepo.Object);
oven.SendTweenToServer(tweet);
tweetRepo.Verify(p => p.SaveTweet(It.Is <string>(k => k == tweet)),
"Message not saved");
}
public void SendTweetToServerShouldSendTheMessageToItsServer()
{
var writer = new Mock <IWriter>();
var tweetRepo = new Mock <ITweetRepository>();
tweetRepo.Setup(tr => tr.SaveTweet(It.IsAny <string>()));
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
microwaveOven.SendTweetToServer(Message);
tweetRepo.Verify(tr => tr.SaveTweet(It.Is <string>(s => s == Message)),
Times.Once,
"Message is not sent to the server");
}
public void SendTweetToServerShouldSendTheMessageToItsServer()
{
// Arraneg
var writer = new Mock <IWriter>();
var tweetRepo = new Mock <ITweetRepository>();
tweetRepo.Setup(tr => tr.SaveTweet(It.IsAny <string>()));
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
// Act
microwaveOven.SendTweetToServer(Message);
// Assert
tweetRepo.Verify(tr => tr.SaveTweet(It.Is <string>(s => s == Message)));
}
public void WriteTweetShouldCallItsWriterWithTheTweetsMessage()
{
// Arraneg
var writer = new Mock <IWriter>();
writer.Setup(w => w.WriteLine(It.IsAny <string>()));
var tweetRepo = new Mock <ITweetRepository>();
var microwaveOven = new MicrowaveOven(writer.Object, tweetRepo.Object);
// Act
microwaveOven.WriteTweet(Message);
// Assert
writer.Verify(w => w.WriteLine(It.Is <string>(s => s == Message)));
}
public void Test_WriteTweetShouldCallItsWriterWithTheTweetsMessage()
{
//prepare
var writerMock = new Mock <IWriter>();
var message = string.Empty;
writerMock.Setup(o => o.WriteLine(It.IsAny <string>())).Callback((string mess) => message = mess);
var repoMock = new Mock <ITweetRepository>();
var classUnderTest = new MicrowaveOven(writerMock.Object, repoMock.Object);
//act
classUnderTest.WriteTweet("My message!");
//check
writerMock.Verify(o => o.WriteLine(It.IsAny <string>()), Times.Exactly(1));
Assert.Equal("My message!", message);
}
public void Test_SendTweetToServerShouldSendTheMessageToItsServer()
{
//prepare
var writerMock = new Mock <IWriter>();
var repoMock = new Mock <ITweetRepository>();
var message = "test";
repoMock.Setup(o => o.SaveTweet(It.IsAny <string>())).Callback((string mess) => message = mess);
var classUnderTest = new MicrowaveOven(writerMock.Object, repoMock.Object);
//act
classUnderTest.SendTweetToServer("My message!");
//check
repoMock.Verify(o => o.SaveTweet("My message!"), Times.Exactly(1));
Assert.Equal("My message!", message);
}
public void TestInvalidMessageReceivment(string messageText)
{
var fakeMessage = new Mock <ITweet>();
fakeMessage.Setup(m => m.RetrieveMessage())
.Returns(messageText);
var fakeServer = new Mock <IServer>();
fakeServer.Setup(s => s.ReceiveMessage(fakeMessage.Object))
.Returns(false);
var expectedValue = false;
var microwaveOven = new MicrowaveOven(fakeServer.Object);
bool actualValue = microwaveOven.ReceiveMessage(fakeMessage.Object);
Assert.That(actualValue, Is.EqualTo(expectedValue));
}
public bool HasMicrowaveOven(MicrowaveOven MicrowaveOven)
{
return(MicrowaveOvens.Contains(MicrowaveOven));
}
