public void create_and_save_test_collection_to_disk() { int numberOfCollectables = 2; int numberOfItemsPerCollectable = 3; foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { // Initialize the collection string collectionName = $"Test {collectionType.Name} Collection"; ICollectionBase testCollection = GetTestCollection(collectionName, collectionType, numberOfCollectables, numberOfItemsPerCollectable); // Initialize a repository IFileIO fileIO = new FileIO(); HomeCollectionRepository repo = new HomeCollectionRepository(testCollection, fileIO); // Write file to disk string fullFilePath = Environment.CurrentDirectory + @"\"; fullFilePath += collectionName + @"." + HomeCollectionRepository.FILE_EXTENSION; try { repo.SaveCollection(fullFilePath, true); Assert.IsTrue(true); } catch (Exception ex) { Assert.Fail($"Should not have failed to write test collection file to disk: {collectionType.Name}", ex.Message); } } }
public void converttojson_collection_with_collectables_and_instances_success() { int N = 3; int M = 2; foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { ICollectionBase collection = GetTestCollection("initial", collectionType, N, M); string json = HomeCollectionRepository.ConvertCollectionToJson(collection); int countCollectionNameTag = CountOccurences(json, "CollectionName"); int countCollectionTypeTag = CountOccurences(json, "CollectionType"); int countDisplayNameTag = CountOccurences(json, "DisplayName"); int countDescriptionTag = CountOccurences(json, "Description"); int countItemInstanceTag = CountOccurences(json, "ItemInstances"); int countItemDetailsTag = CountOccurences(json, "ItemDetails"); int countIsFavoriteTag = CountOccurences(json, "IsFavorite"); Assert.AreEqual(1, countCollectionNameTag); Assert.AreEqual(1, countCollectionTypeTag); Assert.AreEqual(N, countDisplayNameTag); Assert.AreEqual(N, countDescriptionTag); Assert.AreEqual(N, countItemInstanceTag); Assert.AreEqual(N * M, countItemDetailsTag); Assert.AreEqual(N * M, countIsFavoriteTag); } }
public void convertcollectiontojson_throws_exception_when_collection_is_null() { ICollectionBase collection = null; string json = HomeCollectionRepository.ConvertCollectionToJson(collection); Assert.Fail("Should have thrown exception when collection is null"); }
public void stripinvalidjson_throws_exception_when_passed_null() { char padding = 'X'; string test = null; string output = HomeCollectionRepository.StripInvalidJson(test, padding); Assert.Fail("Expected exception to be thrown when passed null"); }
public void loadcollection_fileio_not_found_throws_exception() { IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); _mockFileIO.Setup(i => i.ReadFile(It.IsAny <string>())).Throws(new CollectionException()); string fullFilePath = "badfilepath"; ICollectionBase collection = repo.LoadCollection(fullFilePath); Assert.Fail($"Expected exception to be thrown when the file is not found: {fullFilePath}"); }
public void loadcollection_file_invalid_json_content_throws_exception() { IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); string mockFileContent = "this is some invalid Json content"; _mockFileIO.Setup(i => i.ReadFile(It.IsAny <string>())).Returns(mockFileContent); string fullFilePath = "filepath"; ICollectionBase collection = repo.LoadCollection(fullFilePath); Assert.Fail($"Expected exception to be thrown when the file content cannot be parsed into a collection: {fullFilePath}"); }
public void convertcollectiontojson_serializes_new_collection_successfully() { string collectionName = "test"; Type collectableType = CollectableBaseFactory.CollectableTypes[0]; ICollectionBase collection = new HomeCollection(collectionName, collectableType); string expected = @"{""CollectionName"":""test"",""CollectionType"":""HomeCollector.Models.BookBase, HomeCollector, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"",""Collectables"":[]}"; string json = HomeCollectionRepository.ConvertCollectionToJson(collection); // This is a very fragile test. Should look for expected tokens instead. Assert.AreEqual(expected, json); }
public void instanceitem_serialize_deserialize_stamp_type_success() { StampItem item = GetTestStampItem(4); string jsonItem = JsonConvert.SerializeObject(item); StampItem newItem = (StampItem)HomeCollectionRepository.GetCollectableItemFromJson(jsonItem, item.CollectableType); Assert.AreEqual(item.CollectableType, newItem.CollectableType); Assert.AreEqual(item.EstimatedValue, newItem.EstimatedValue); Assert.AreEqual(item.ItemDetails, newItem.ItemDetails); Assert.AreEqual(item.IsFavorite, newItem.IsFavorite); Assert.AreEqual(item.Condition, newItem.Condition); }
public void savecollection_calls_writefile_with_overwrite_flag_set() { Mock <ICollectionBase> mockCollection = new Mock <ICollectionBase>(); IHomeCollectionRepository repo = new HomeCollectionRepository(mockCollection.Object, _mockFileIO.Object); string path = "filepath"; string filename = "filename"; bool overwrite = false; repo.SaveCollection(path, filename, overwrite); _mockFileIO.Verify(r => r.WriteFile(It.IsAny <string>(), It.IsAny <string>(), overwrite), Times.Once); }
public void initialize_homecollectionrepository_collectionless_constructor_succeeds() { try { IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); Assert.IsInstanceOfType(repo, typeof(HomeCollectionRepository)); } catch { Assert.Fail("HomeCollectionRepository initialization was expected to successfully initialize"); } }
public void convertjsontocollection_deserializes_to_collection_success() { string expectedCollectionName = "test"; string jsonBookCollection = @"{""CollectionName"":""test"",""CollectionType"":""HomeCollector.Models.BookBase, HomeCollector, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"",""Collectables"":[]}"; ICollectionBase collection = HomeCollectionRepository.ConvertJsonToCollection(jsonBookCollection); // This is a very fragile test. Should look for expected tokens instead. Assert.AreEqual(expectedCollectionName, collection.CollectionName); Assert.AreEqual(0, collection.Collectables.Count); Assert.AreEqual(CollectableBaseFactory.BookType, collection.CollectionType); }
public void stripinvalidjson_replaces_multiple_invalid_characters() { char padding = 'v'; foreach (char c in HomeCollectionRepository.INVALID_JSON_CHARS) { string test = $"{c}test{c}test{c}"; string expected = $"{padding}test{padding}test{padding}"; string output = HomeCollectionRepository.StripInvalidJson(test, padding); Assert.AreEqual(expected, output); } }
public void load_test_book_collection_from_disk() { string collectionName = "Star Trek Books - YTH"; // Initialize a repository IFileIO fileIO = new FileIO(); HomeCollectionRepository repo = new HomeCollectionRepository(fileIO); string fullFilePath = Environment.CurrentDirectory + @"\"; fullFilePath += collectionName + @"." + HomeCollectionRepository.FILE_EXTENSION; ICollectionBase books = repo.LoadCollection(fullFilePath); }
public void initialize_homecollectionrepository_with_collection_success() { Mock <ICollectionBase> mockCollection = new Mock <ICollectionBase>(); try { IHomeCollectionRepository repo = new HomeCollectionRepository(mockCollection.Object, _mockFileIO.Object); Assert.IsTrue(true); } catch { Assert.Fail("HomeCollectionRepository was not successfully initialized"); } }
public void initialize_homecollectionrepository_with_null_fails() { ICollectionBase nullCollection = null; try { IHomeCollectionRepository repo = new HomeCollectionRepository(nullCollection, _mockFileIO.Object); Assert.Fail("HomeCollectionRepository initialization was expected to fail when passed a null value"); } catch { Assert.IsTrue(true); } }
public void load_test_stamp_collection_from_disk() { string collectionName = "USA Stamps - Special"; //string collectionName = "Test StampBase Collection_formatted"; // Initialize a repository IFileIO fileIO = new FileIO(); HomeCollectionRepository repo = new HomeCollectionRepository(fileIO); string fullFilePath = Environment.CurrentDirectory + @"\"; fullFilePath += collectionName + @"." + HomeCollectionRepository.FILE_EXTENSION; ICollectionBase stamps = repo.LoadCollection(fullFilePath); }
public void savecollection_fails_when_collection_is_null() { // initalize repository without a collection IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); string fullFilePath = "fullfilepath"; try { repo.SaveCollection(fullFilePath, false); Assert.Fail("Expected save to fail when the collection is null"); } catch (CollectionException) { Assert.IsTrue(true); } }
public void loadcollection_file_valid_json_content_returns_collection() { IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { ICollectionBase testCollection = GetTestCollection("test collection", collectionType, 1); string testFileContent = HomeCollectionRepository.ConvertCollectionToJson(testCollection); _mockFileIO.Setup(i => i.ReadFile(It.IsAny <string>())).Returns(testFileContent); string fullFilePath = "filepath"; ICollectionBase collection = repo.LoadCollection(fullFilePath); Assert.IsNotNull(collection); } }
public void savecollection_calls_writefile_with_fullpath_set() { Mock <ICollectionBase> mockCollection = new Mock <ICollectionBase>(); IHomeCollectionRepository repo = new HomeCollectionRepository(mockCollection.Object, _mockFileIO.Object); _mockFileIO.Setup(f => f.GetFullFilePath(It.IsAny <string>(), It.IsAny <string>())).Returns((string p, string f) => p + @"\" + f); //_mockFileIO.Setup(f => f.GetFullFilePath(It.IsAny<string>(), It.IsAny<string>())).Returns(@"filepath\filename"); string path = "filepath"; string filename = "filename"; string fullFilePath = FileIO.GetFullFilePathString(path, filename); bool overwrite = false; repo.SaveCollection(path, filename, overwrite); _mockFileIO.Verify(r => r.WriteFile(fullFilePath, It.IsAny <string>(), It.IsAny <bool>()), Times.Once); }
public void savecollection_fails_when_filename_is_blank() { Mock <ICollectionBase> mockCollection = new Mock <ICollectionBase>(); IHomeCollectionRepository repo = new HomeCollectionRepository(mockCollection.Object, _mockFileIO.Object); string path = "filepath"; string filename = ""; try { repo.SaveCollection(path, filename, false); Assert.Fail("Expected save to fail when the filename is blank"); } catch (CollectionException) { Assert.IsTrue(true); } }
public void getcollectablefromjson_deserialize_bad_format_throws_exception() { string jsonCollectable = "invalid JSON"; foreach (Type collectableType in CollectableBaseFactory.CollectableTypes) { bool fail = false; try { ICollectableBase newCollectable = HomeCollectionRepository.GetCollectableFromJson(jsonCollectable, collectableType); } catch (CollectableParseException) { fail = true; Assert.IsTrue(fail, "Expected exception to be thrown when JSON is invalid and cannot be parsed to an object"); } } }
public void collection_serialize_deserialize_success() { string collectionName = "test"; int numberOfCollectables = 2; int numberOfItemsPerCollectable = 2; foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { ICollectionBase testCollection = GetTestCollection(collectionName, collectionType, numberOfCollectables, numberOfItemsPerCollectable); string jsonCollection = HomeCollectionRepository.ConvertCollectionToJson(testCollection); ICollectionBase resultCollection = HomeCollectionRepository.ConvertJsonToCollection(jsonCollection); Assert.AreEqual(collectionName, resultCollection.CollectionName); Assert.AreEqual(collectionType, resultCollection.CollectionType); Assert.AreEqual(numberOfCollectables, resultCollection.Collectables.Count); Assert.AreEqual(numberOfCollectables * numberOfItemsPerCollectable, resultCollection.Collectables.Count * resultCollection.Collectables[0].ItemInstances.Count); } }
public void loadcollection_with_path_filename_calls_getfullfilepath() { IHomeCollectionRepository repo = new HomeCollectionRepository(_mockFileIO.Object); _mockFileIO.Setup(f => f.GetFullFilePath(It.IsAny <string>(), It.IsAny <string>())) .Returns((string p, string f) => p + @"\" + f); foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { ICollectionBase testCollection = GetTestCollection("test collection", collectionType, 1); string testFileContent = HomeCollectionRepository.ConvertCollectionToJson(testCollection); _mockFileIO.Setup(i => i.ReadFile(It.IsAny <string>())).Returns(testFileContent); string path = "path"; string filename = "filename"; ICollectionBase collection = repo.LoadCollection(path, filename); } _mockFileIO.Verify(r => r.GetFullFilePath(It.IsAny <string>(), It.IsAny <string>()), Times.Exactly(CollectableBaseFactory.CollectableTypes.Count)); }
public void stripinvalidjson_replaces_multiple_mixed_invalid_characters() { char padding = 'X'; string test = "test"; string expected = "test"; string output = ""; foreach (char c in HomeCollectionRepository.INVALID_JSON_CHARS) { test += $"{c}test"; expected += $"{padding}test"; } output = test; foreach (char c in HomeCollectionRepository.INVALID_JSON_CHARS) { output = HomeCollectionRepository.StripInvalidJson(output, padding); } Assert.AreEqual(expected, output); }
public void collectable_serialize_deserialize_stamp_success() { StampBase collectable = GetTestStampBase(5); collectable.AddItem(GetTestStampItem(0)); collectable.AddItem(GetTestStampItem(1)); collectable.AddItem(GetTestStampItem(2)); string jsonItem = JsonConvert.SerializeObject(collectable); StampBase newCollectable = (StampBase)HomeCollectionRepository.GetCollectableFromJson(jsonItem, collectable.CollectableType); //JsonConvert.DeserializeObject<StampBase>(jsonItem); Assert.AreEqual(collectable.CollectableType, newCollectable.CollectableType); Assert.AreEqual(collectable.AlternateId, newCollectable.AlternateId); Assert.AreEqual(collectable.Country, newCollectable.Country); Assert.AreEqual(collectable.Description, newCollectable.Description); Assert.AreEqual(collectable.DisplayName, newCollectable.DisplayName); Assert.AreEqual(collectable.FirstDayOfIssue, newCollectable.FirstDayOfIssue); Assert.AreEqual(collectable.IsPostageStamp, newCollectable.IsPostageStamp); Assert.AreEqual(collectable.ScottNumber, newCollectable.ScottNumber); Assert.AreEqual(collectable.IssueYearStart, newCollectable.IssueYearStart); }
public void collectable_serialize_deserialize_book_success() { BookBase collectable = GetTestBookBase(2); collectable.AddItem(GetTestBookItem(0)); collectable.AddItem(GetTestBookItem(1)); string jsonCollectable = JsonConvert.SerializeObject(collectable); BookBase newCollectable = (BookBase)HomeCollectionRepository.GetCollectableFromJson(jsonCollectable, collectable.CollectableType); //JsonConvert.DeserializeObject<BookBase>(jsonCollectable); Assert.AreEqual(collectable.CollectableType, newCollectable.CollectableType); Assert.AreEqual(collectable.Author, newCollectable.Author); Assert.AreEqual(collectable.BookCode, newCollectable.BookCode); Assert.AreEqual(collectable.Month, newCollectable.Month); Assert.AreEqual(collectable.Description, newCollectable.Description); Assert.AreEqual(collectable.DisplayName, newCollectable.DisplayName); Assert.AreEqual(collectable.Edition, newCollectable.Edition); Assert.AreEqual(collectable.ISBN, newCollectable.ISBN); Assert.AreEqual(collectable.Publisher, newCollectable.Publisher); Assert.AreEqual(collectable.Series, newCollectable.Series); Assert.AreEqual(collectable.Title, newCollectable.Title); Assert.AreEqual(collectable.Year, newCollectable.Year); }
public void convertjsontocollection_deserialize_format_missing_bracket_throws_exception() { string collectionName = "test"; int numberOfCollectables = 2; int numberOfItemsPerCollectable = 2; foreach (Type collectionType in CollectableBaseFactory.CollectableTypes) { ICollectionBase testCollection = GetTestCollection(collectionName, collectionType, numberOfCollectables, numberOfItemsPerCollectable); string jsonCollectionMissingTrailingBracket = HomeCollectionRepository.ConvertCollectionToJson(testCollection); string jsonCollectionMissingLeadingBracket = jsonCollectionMissingTrailingBracket; jsonCollectionMissingTrailingBracket = jsonCollectionMissingTrailingBracket.TrimEnd('}'); // remove bracket jsonCollectionMissingLeadingBracket = jsonCollectionMissingLeadingBracket.TrimStart('{'); // remove bracket bool failTrailing = false; bool failLeading = false; try { ICollectionBase resultCollection = HomeCollectionRepository.ConvertJsonToCollection(jsonCollectionMissingTrailingBracket); } catch (CollectionParseException) { failTrailing = true; } try { ICollectionBase resultCollection = HomeCollectionRepository.ConvertJsonToCollection(jsonCollectionMissingTrailingBracket); } catch (CollectionParseException) { failLeading = true; } Assert.IsTrue(failTrailing, "Expect exception to be thrown when missing JSON bracket(s)"); Assert.IsTrue(failLeading, "Expect exception to be thrown when missing JSON bracket(s)"); } }