public void ConvertJstBroadcastTimeToSelectedTimeZone_GivenEmptyJstBroadcastTime_SetLocalBroadcastTimeForToday()
{
// Arrange
var sut = new MiruAnimeModel {
JSTBroadcastTime = null
};
// Act
sut.ConvertJstBroadcastTimeToSelectedTimeZone(It.IsAny <TimeZoneInfo>());
// Assert
Assert.True(sut.LocalBroadcastTime == DateTime.Today);
}
public void GetDetailedSeasonAnimeListInfo_GivenConnectionIssuesWithGettingAnimeInfo_ReturnsNull()
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var mockContext = new Mock <IMiruDbContext>();
var date = new DateTime(2020, 01, 26, 10, 0, 0);
var testModel = new MiruAnimeModel
{
Title = "initial title",
Type = "TV",
MalId = 1L,
Broadcast = "Sundays at 10:00 (JST)",
JSTBroadcastTime = date,
IsOnWatchingList = false,
WatchedEpisodes = 0,
TotalEpisodes = 20,
CurrentlyAiring = false,
ImageURL = "stays the same",
URL = "same",
LocalImagePath = "\\same"
};
var data = new List <MiruAnimeModel>
{
testModel,
}.AsQueryable();
var seasonAnimeEntryList = new List <AnimeSubEntry>()
{
new AnimeSubEntry()
{
MalId = 39, Title = "new season entry", Type = "TV", URL = "only value from seasonEntry"
}
};
var animeEntryList = new List <AnimeListEntry>()
{
};
var cls = SetupMiruDbServiceMock(mockContext, mock, miruDbContext: out IMiruDbContext db, currentUserAnimeEntryList: animeEntryList,
currentSeasonList: seasonAnimeEntryList, miruAnimeModelDbSetData: data, fakeConnectionIssues: true);
// Act
var result = cls.GetDetailedUserAnimeList(db, animeEntryList, true).Result;
// Assert
Assert.Null(result);
}
}
public void ParseTimeFromBroadcast_AnimeIsInSenpaiEntriesAndAirdateParseFailsTwice_SetsCorrectBroadcastTimes()
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var senpaiEntry = @"{
""Items"": [
{
""MALID"": 40507,
""airdate"": ""1337/1/2022 23:30""
}
]
}";
var jpCultureInfo = CultureInfo.GetCultureInfo("ja-JP");
string[] formats = { "dd/MM/yyyy HH:mm", "d/MM/yyyy HH:mm", "dd/M/yyyy HH:mm", "d/M/yyyy HH:mm" };
var deserializedSenpaiEntry = JsonConvert.DeserializeObject <SenpaiEntryModel>(senpaiEntry);
mock.Mock <IFileSystemService>().Setup(x => x.FileSystem.File.ReadAllText(It.IsAny <string>())).Returns(senpaiEntry);
string airingAnimeBroadcastInMalFormat = "Mondays at 18:00";
var mockFileSystemService = mock.Create <IFileSystemService>();
var sut = new List <MiruAnimeModel>
{
new MiruAnimeModel {
Title = "10", Type = "TV", MalId = 40507, Broadcast = airingAnimeBroadcastInMalFormat,
},
};
// Act
sut.ParseTimeFromBroadcast(mockFileSystemService);
var parsedBroadcast = new DateTime(2020, 01, 20, 18, 0, 0);
var expectedLocalBroadcastAnime = new MiruAnimeModel()
{
JSTBroadcastTime = parsedBroadcast
};
expectedLocalBroadcastAnime.ConvertJstBroadcastTimeToSelectedTimeZone(TimeZoneInfo.Local);
// Assert
Assert.False(sut.First().IsOnSenpai);
Assert.Equal(airingAnimeBroadcastInMalFormat, sut.First().Broadcast);
Assert.Equal(parsedBroadcast, sut.First().JSTBroadcastTime);
Assert.Equal(expectedLocalBroadcastAnime.LocalBroadcastTime, sut.First().LocalBroadcastTime);
}
}
public void ParseTimeFromBroadcast_AnimeIsInSenpaiEntriesAndAirdateParseIsSuccessful_SetsCorrectBroadcastTimes()
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var senpaiEntry = @"{
""Items"": [
{
""MALID"": 40507,
""airdate"": ""13/1/2022 23:30""
}
]
}";
var jpCultureInfo = CultureInfo.GetCultureInfo("ja-JP");
string[] formats = { "dd/MM/yyyy HH:mm", "d/MM/yyyy HH:mm", "dd/M/yyyy HH:mm", "d/M/yyyy HH:mm" };
var deserializedSenpaiEntry = JsonConvert.DeserializeObject <SenpaiEntryModel>(senpaiEntry);
mock.Mock <IFileSystemService>().Setup(x => x.FileSystem.File.ReadAllText(It.IsAny <string>())).Returns(senpaiEntry);
var mockFileSystemService = mock.Create <IFileSystemService>();
var sut = new List <MiruAnimeModel>
{
new MiruAnimeModel {
Title = "10", Type = "TV", MalId = 40507, Broadcast = "",
},
};
// Act
sut.ParseTimeFromBroadcast(mockFileSystemService);
var parsed = DateTime.TryParseExact(deserializedSenpaiEntry.Items.First().Airdate, formats, jpCultureInfo, DateTimeStyles.None, out DateTime parsedSenpaiBroadcast);
var compareLocalBroadcastAnime = new MiruAnimeModel()
{
JSTBroadcastTime = parsedSenpaiBroadcast
};
compareLocalBroadcastAnime.ConvertJstBroadcastTimeToSelectedTimeZone(TimeZoneInfo.Local);
// Assert
Assert.True(sut.First().IsOnSenpai);
Assert.Equal(deserializedSenpaiEntry.Items.First().Airdate, sut.First().Broadcast);
Assert.Equal(parsedSenpaiBroadcast, sut.First().JSTBroadcastTime);
Assert.Equal(compareLocalBroadcastAnime.LocalBroadcastTime, sut.First().LocalBroadcastTime);
}
}
public void SetAiringAnimeModelData_GivenValidInput_SetsDataCorrectly(AiringStatus airingStatus, string broadcast)
{
// Arrange
var sut = new MiruAnimeModel();
DateTime airedFromDate = new DateTime(2022, 3, 14);
var animeInfo = new Anime()
{
MalId = MAL_ID,
Broadcast = broadcast,
Title = TITLE,
ImageURL = IMAGE_URL,
Type = TYPE,
Aired = new TimePeriod()
{
From = airedFromDate
}
};
var animeListEntry = new AnimeListEntry()
{
TotalEpisodes = TOTAL_EPISODES,
URL = URL,
WatchedEpisodes = WATCHED_EPISODES,
AiringStatus = airingStatus
};
// Act
sut.SetAiringAnimeModelData(animeInfo, animeListEntry);
// Assert
Assert.Equal(MAL_ID, sut.MalId);
Assert.Equal(TITLE, sut.Title);
Assert.Equal(IMAGE_URL, sut.ImageURL);
Assert.Equal(TOTAL_EPISODES, sut.TotalEpisodes);
Assert.Equal(URL, sut.URL);
Assert.Equal(WATCHED_EPISODES, sut.WatchedEpisodes);
Assert.Equal(TYPE, sut.Type);
Assert.True(sut.IsOnWatchingList);
Assert.Equal(Path.Combine(Constants.ImageCacheFolderPath, $"{ MAL_ID }.jpg"), sut.LocalImagePath);
Assert.Equal(airingStatus == AiringStatus.Airing, sut.CurrentlyAiring);
Assert.Equal(broadcast ?? airedFromDate.ToString(), sut.Broadcast);
}
public void SaveDetailedAnimeListData_ParseTimeFromBroadcast_SetsCorrectBroadcastTimes()
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var mockContext = new Mock <IMiruDbContext>();
var data = new List <MiruAnimeModel>
{
new MiruAnimeModel {
Title = "10", Type = "TV", MalId = 1, Broadcast = "Sundays at 10:00 (JST)",
},
}.AsQueryable();
var animeEntryList = new List <AnimeListEntry>()
{
new AnimeListEntry()
{
MalId = 1, AiringStatus = AiringStatus.Airing, WatchedEpisodes = 5, TotalEpisodes = 10, Type = "TV", Title = "10",
}
};
var cls = SetupMiruDbServiceMock(mockContext, mock, miruAnimeModelDbSetData: data, currentUserAnimeEntryList: animeEntryList);
var date = new DateTime(2020, 01, 26, 10, 0, 0);
cls.UpdateAppStatusUI += (x, y) => x.ToString();
var testModel = new MiruAnimeModel {
Title = "10", Type = "TV", MalId = 1, Broadcast = "Sundays at 10:00 (JST)", JSTBroadcastTime = date
};
// Act
cls.SaveDetailedAnimeListData(It.IsAny <bool>()).Wait();
testModel.ConvertJstBroadcastTimeToSelectedTimeZone(TimeZoneInfo.Local);
// Assert
mockContext.Verify(x => x.MiruAnimeModels
.AddRange(It.Is <List <MiruAnimeModel> >(
y => y.Select(z => z.JSTBroadcastTime == date &&
z.LocalBroadcastTime == testModel.LocalBroadcastTime)
.ToList().Any())), Times.Once());
}
}
public void SetSeasonalAnimeModelData_ValidInput_SetsDataCorrectly(string broadcast)
{
// Arrange
var sut = new MiruAnimeModel();
DateTime airedFromDate = new DateTime(2022, 3, 14);
var animeInfo = new Anime()
{
MalId = MAL_ID,
Broadcast = broadcast,
Title = TITLE,
ImageURL = IMAGE_URL,
Type = TYPE,
Aired = new TimePeriod()
{
From = airedFromDate
}
};
var animeSubEntry = new AnimeSubEntry()
{
URL = URL,
};
// Act
sut.SetSeasonalAnimeModelData(animeInfo, animeSubEntry);
// Assert
Assert.Equal(MAL_ID, sut.MalId);
Assert.Equal(TITLE, sut.Title);
Assert.Equal(IMAGE_URL, sut.ImageURL);
Assert.Equal(URL, sut.URL);
Assert.Equal(TYPE, sut.Type);
Assert.False(sut.IsOnWatchingList);
Assert.Equal(Path.Combine(Constants.ImageCacheFolderPath, $"{ MAL_ID }.jpg"), sut.LocalImagePath);
Assert.True(sut.CurrentlyAiring);
Assert.Equal(broadcast ?? airedFromDate.ToString(), sut.Broadcast);
}
public void GetDetailedSeasonAnimeListInfo_GivenAnimeList_ReturnsUpdatedList()
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var mockContext = new Mock <IMiruDbContext>();
var date = new DateTime(2020, 01, 26, 10, 0, 0);
var testModel = new MiruAnimeModel
{
Title = "initial title",
Type = "TV",
MalId = 1L,
Broadcast = "Sundays at 10:00 (JST)",
JSTBroadcastTime = date,
IsOnWatchingList = false,
WatchedEpisodes = 0,
TotalEpisodes = 20,
CurrentlyAiring = false,
ImageURL = "stays the same",
URL = "same",
LocalImagePath = "\\same"
};
var data = new List <MiruAnimeModel>
{
testModel,
}.AsQueryable();
var seasonAnimeEntryList = new List <AnimeSubEntry>()
{
new AnimeSubEntry()
{
MalId = 1, Title = "old entry", Type = "ONA", URL = "only value from seasonEntry"
},
new AnimeSubEntry()
{
MalId = 39, Title = "new season entry", Type = "TV", URL = "only value from seasonEntry"
}
};
var animeEntryList = new List <AnimeListEntry>()
{
};
var cls = SetupMiruDbServiceMock(mockContext, mock, miruDbContext: out IMiruDbContext db, currentUserAnimeEntryList: animeEntryList,
currentSeasonList: seasonAnimeEntryList, miruAnimeModelDbSetData: data);
// Act
var result = cls.GetDetailedUserAnimeList(db, animeEntryList, true).Result;
var resultNewEntry = result.First(x => x != testModel);
var resultUpdatedEntry = result.First(x => x == testModel);
// Assert
Assert.True(resultUpdatedEntry.CurrentlyAiring);
// check if rest of the values for updated entry stay the same
Assert.False(resultUpdatedEntry.IsOnWatchingList);
Assert.Equal(1L, resultUpdatedEntry.MalId);
Assert.Equal("Sundays at 10:00 (JST)", resultUpdatedEntry.Broadcast);
Assert.Equal("initial title", resultUpdatedEntry.Title);
Assert.Equal("stays the same", resultUpdatedEntry.ImageURL);
Assert.Equal("\\same", resultUpdatedEntry.LocalImagePath);
Assert.Equal("same", resultUpdatedEntry.URL);
Assert.Equal("TV", resultUpdatedEntry.Type);
// check new entry
Assert.Equal(39, resultNewEntry.MalId);
Assert.Equal("Sundays at 10:00 (JST)", resultNewEntry.Broadcast); // it is set in webServiceMock
Assert.Equal("new season entry", resultNewEntry.Title);
Assert.Equal("\\dydo", resultNewEntry.ImageURL); // it is set in webServiceMock
Assert.Equal(Path.Combine(Constants.ImageCacheFolderPath, $"{ 39 }.jpg"), resultNewEntry.LocalImagePath);
Assert.Equal("only value from seasonEntry", resultNewEntry.URL);
Assert.False(resultNewEntry.IsOnWatchingList);
Assert.True(resultNewEntry.CurrentlyAiring);
Assert.Equal("TV", resultNewEntry.Type);
}
}
public void GetDetailedUserAnimeList_GivenNotNullUserAnimeListEntries_ReturnsDetailedList(
// 1st entry updated exisiting
int expectedUpdatedWatchedEpisodesValue,
int expectedUpdatedTotalEpisodesValue,
AiringStatus updatedAiringStatus,
// 2nd entry -- new one
long expectedMalIdOfNewEntry,
AiringStatus expectedAiringStatusOfNewEntry,
string titleOfNewEntry,
int watchedEpisodesOfNewEntry,
int totalEpisodesOfNewEntry,
string typeOfNewEntry,
string urlOfNewEntry)
{
using (var mock = AutoMock.GetLoose())
{
// Arrange
var mockContext = new Mock <IMiruDbContext>();
var date = new DateTime(2020, 01, 26, 10, 0, 0);
var testModel = new MiruAnimeModel {
Title = "initial title", Type = "TV", MalId = 1L, Broadcast = "Sundays at 10:00 (JST)", JSTBroadcastTime = date,
IsOnWatchingList = false, WatchedEpisodes = 0, TotalEpisodes = 20, CurrentlyAiring = false, ImageURL = "stays the same", URL = "same", LocalImagePath = "\\same"
};
var data = new List <MiruAnimeModel>
{
testModel,
}.AsQueryable();
var animeEntryList = new List <AnimeListEntry>()
{
new AnimeListEntry()
{
MalId = 1L, AiringStatus = updatedAiringStatus, WatchedEpisodes = expectedUpdatedWatchedEpisodesValue,
TotalEpisodes = expectedUpdatedTotalEpisodesValue, Type = "TV", Title = "changed"
},
new AnimeListEntry()
{
MalId = expectedMalIdOfNewEntry, AiringStatus = expectedAiringStatusOfNewEntry,
WatchedEpisodes = watchedEpisodesOfNewEntry, TotalEpisodes = totalEpisodesOfNewEntry, Type = typeOfNewEntry, Title = titleOfNewEntry, URL = urlOfNewEntry
}
};
var cls = SetupMiruDbServiceMock(mockContext, mock, miruDbContext: out IMiruDbContext db, currentUserAnimeEntryList: animeEntryList, miruAnimeModelDbSetData: data);
// Act
var result = cls.GetDetailedUserAnimeList(db, cls.CurrentUserAnimeList.UserAnimeListData.Anime, It.IsAny <bool>()).Result;
var resultUpdatedEntry = result.First(x => x == testModel);
var resultNewEntry = result.First(x => x != testModel);
// Assert
Assert.Equal(2, result.Count());
// check updated anime entry - only 4 values should change
Assert.True(resultUpdatedEntry.IsOnWatchingList); // should change to true
Assert.Equal(updatedAiringStatus == AiringStatus.Airing, resultUpdatedEntry.CurrentlyAiring); // should change depending on airing status
Assert.Equal(expectedUpdatedWatchedEpisodesValue, resultUpdatedEntry.WatchedEpisodes); // should change to new value
Assert.Equal(expectedUpdatedTotalEpisodesValue, resultUpdatedEntry.TotalEpisodes); // should change to new value
// check if rest of the values for updated entry stay the same
Assert.Equal(1L, resultUpdatedEntry.MalId);
Assert.Equal("Sundays at 10:00 (JST)", resultUpdatedEntry.Broadcast);
Assert.Equal("initial title", resultUpdatedEntry.Title);
Assert.Equal("stays the same", resultUpdatedEntry.ImageURL);
Assert.Equal("\\same", resultUpdatedEntry.LocalImagePath);
Assert.Equal("same", resultUpdatedEntry.URL);
Assert.Equal("TV", resultUpdatedEntry.Type);
// check new entry
Assert.Equal(expectedMalIdOfNewEntry, resultNewEntry.MalId);
Assert.Equal("Sundays at 10:00 (JST)", resultNewEntry.Broadcast); // it is set in webServiceMock
Assert.Equal(titleOfNewEntry, resultNewEntry.Title);
Assert.Equal("\\dydo", resultNewEntry.ImageURL); // it is set in webServiceMock
Assert.Equal(Path.Combine(Constants.ImageCacheFolderPath, $"{ expectedMalIdOfNewEntry }.jpg"), resultNewEntry.LocalImagePath);
Assert.Equal(totalEpisodesOfNewEntry, resultNewEntry.TotalEpisodes);
Assert.Equal(urlOfNewEntry, resultNewEntry.URL);
Assert.Equal(watchedEpisodesOfNewEntry, resultNewEntry.WatchedEpisodes);
Assert.True(resultNewEntry.IsOnWatchingList);
Assert.Equal(expectedAiringStatusOfNewEntry == AiringStatus.Airing, resultNewEntry.CurrentlyAiring);
Assert.Equal(typeOfNewEntry, resultNewEntry.Type);
}
}
