public void returns_null_if_exception()
{
_mock.Setup(m => m.Add(It.IsAny<Book>())).Throws<Exception>();
_service = new BookService(_mock.Object);
Assert.IsNull(_service.Add(_newBook));
}
public void when_succesful_object_returned()
{
_mock.Setup(m => m.Add(_newBook)).Returns(_newBook);
_service = new BookService(_mock.Object);
var result = _service.Add(_newBook);
Assert.AreEqual(_newBook.Title, result.Title);
Assert.AreEqual(_newBook.Author, result.Author);
Assert.AreEqual(_newBook.ISBN, result.ISBN);
}
public void CanAddPosition()
{
// Arrange
using (var session = SessionFactory.OpenSession())
{
var bs = new BookService(session);
// Act
bs.Add(Board.Start);
}
// Assert
using (var session = SessionFactory.OpenSession())
{
var found = (from b in session.Query<Board>()
select b).ToList();
Assert.AreEqual(2, found.Count());
}
}
public ActionResult Add(BookModel model, string BtnSubmit)
{
switch (BtnSubmit)
{
case "保存":
if (ModelState.IsValid)
{
_service.Add(model);
return(RedirectToAction("Index"));
}
else
{
return(View("AddNew"));
}
case "取消":
return(RedirectToAction("Index"));
}
return(new EmptyResult());
}
public void BookCanFindPositions()
{
// Arrange
using (var session = SessionFactory.OpenSession())
{
var book = new BookService(session);
book.Add(Board.Start);
}
using (var session = SessionFactory.OpenSession())
{
// Act
var book = new BookService(session);
var found = book.Find(Board.Start);
// Assert
Assert.IsNotNull(found);
Assert.AreEqual(Board.Start.MinimalReflection(), found);
}
}
public async void Add()
{
using (var context = new BookCollectionContext(ContextOptions))
{
IBookService BookService = new BookService(context);
Book newBook = new Book
{
Title = "Title1",
Author = "AuthorA",
Description = "Some description"
};
Book addedBook = await BookService.Add(newBook);
context.Books.Remove(addedBook);
await context.SaveChangesAsync();
Assert.True(addedBook.Id > 0);
}
}
public ActionResult Insert(Book item, HttpPostedFileBase pic)
{
ViewBag.CategoryID = new SelectList(cs.GetAll(), "ID", "Name", item.CategoryID);
ViewBag.AuthorID = new SelectList(aus.GetAll(), "ID", "AuthorLabel", item.AuthorID);
ViewBag.PublisherID = new SelectList(ps.GetAll(), "ID", "CompanyName", item.PublisherID);
if (ModelState.IsValid)
{
bool exist = bs.CheckBook(item, pic);
if (!exist)
{
bool isPicLoaded;
string fileResult = FxFunction.ImageUpload(pic, FolderPath.product, out isPicLoaded);
if (isPicLoaded)
{
item.ImagePath = fileResult;
}
bool newBook = bs.Add(item);
if (newBook)
{
return(RedirectToAction("Index"));
}
else
{
ViewBag.Message = "Operation Unsuccessful";
}
}
else
{
ViewBag.Message = "This book exists in the system. Please check title, auhtor, publisher, release date, translator and language.";
}
}
else
{
ViewBag.Message = "Invalid entry";
}
return(View());
}
public void Change_BookExists_ShouldBeChanged()
{
var fileHandlerMock = new Mock <IFileHandler>();
fileHandlerMock.Setup(x => x.Load()).Returns(new List <Book> {
});
var subject = new BookService(fileHandlerMock.Object);
subject.Add(new Book {
Id = 42, Title = "42"
});
subject.Change(new Book {
Id = 42, Title = "new 42"
});
var result = subject.Get(42);
Assert.IsNotNull(result);
Assert.AreEqual("new 42", result.Title);
}
public void BookService_Add_ShouldBeOk()
{
//Cenário
Book modelo = ObjectMother.GetBook();
//Mock
_mockRepository.Setup(m => m.Save(modelo)).Returns(new Book()
{
Id = 1
});
//Serviço
BookService service = new BookService(_mockRepository.Object);
//Fim Cenário
//Executa
Book resultado = service.Add(modelo);
//Saída
resultado.Should().NotBeNull();
resultado.Id.Should().BeGreaterThan(0);
_mockRepository.Verify(repository => repository.Save(modelo));
}
public HttpResponseMessage Post([FromBody] BookView book)
{
HttpResponseMessage response = null;
try
{
if (book.BookId == null || book.BookId == 0)
{
bookService.Add(ModelViewToModel.ViewBookToBook(book));
}
else
{
bookService.Update(ModelViewToModel.ViewBookToBook(book));
}
response = Request.CreateResponse(HttpStatusCode.OK);
}
catch (Exception e)
{
response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message);
}
return(response);
}
public bool Add([FromBody] Book book)
{
return(_bookService.Add(book));
}
public string Post([FromBody] Book book)
{
bookService.Add(book);
return("Object Added");
}
private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
var filter = new List <string> {
".pdf"
};
var storageFolders = _sourceService.GetAllAsStorageFoldersAsync().Result;
foreach (var storageFolder in storageFolders)
{
var source = _sourceService.GetByUrl(storageFolder.Path);
var options = new QueryOptions(CommonFileQuery.OrderByName, filter);
var ss = storageFolder.CreateItemQueryWithOptions(options);
//Get all PDF files for storagefolder
var pdfFiles = ss.GetItemsAsync().GetAwaiter().GetResult();
for (var i = 0; i < pdfFiles.Count; i++)
{
var progress = Utils.CalculatePercentage(i, 0, pdfFiles.Count);
if (Worker.CancellationPending)
{
e.Cancel = true;
return;
}
var book = new Book
{
Title = Path.GetFileNameWithoutExtension(pdfFiles[i].Name),
Source = source,
FileName = Path.GetFileName(pdfFiles[i].Path),
FullPathAndFileName = pdfFiles[i].Path,
Rating = 0
};
var book1 = book;
var existingBook = _bookService.Exists(book1);
if (existingBook == false) // Add Book
{
var xml = storageFolder.TryGetItemAsync(book.Title + ".xml").GetAwaiter().GetResult();
if (xml != null)
{
book = XmlToBook(xml as StorageFile, book);
}
else
{
book = UseIsbn(pdfFiles[i] as StorageFile, book);
}
var cover = new Cover();
var coverPath = _pdfCover.GenerateCoverImage(book, 0, _sourcerepo, storageFolder, pdfFiles[i] as StorageFile).Result;
cover.FileName = Path.GetFileName(coverPath);
book.Cover = cover;
book = _bookService.Add(book);
Worker.ReportProgress(progress, book);
}
else
{
Tuple <Book, string> exists = new Tuple <Book, string>(book, "Exists");
Worker.ReportProgress(progress, exists);
}
}
}
}
public IActionResult Post(BookModel book)
{
_service.Add(book);
return(Ok());
}
public void Add(Book item)
{
service.Add(item);
}
public IActionResult AddNew([FromForm] Book book)
{
_bookService.Add(book);
return(Redirect("/"));
}
public void Add(Book book)
{
bs.Add(book);
}
public IActionResult Post([FromBody] PostBookViewModel book)
{
_bookService.Add(book);
return(Ok());
}
public void CanAddStartPosition()
{
// Arrange
var start = Board.Start;
// Act
using (var session = SessionFactory.OpenSession())
{
var book = new BookService(session);
book.Add(start);
}
// Assert
using (var session = SessionFactory.OpenSession())
{
var book = new BookService(session);
Assert.That(book.Contains(start));
Assert.That(book.Contains(start.Play(new Move("D3")).MinimalReflection()));
Assert.That(book.Contains(start.Play(new Move("C4")).MinimalReflection()));
Assert.That(book.Contains(start.Play(new Move("F5")).MinimalReflection()));
Assert.That(book.Contains(start.Play(new Move("E6")).MinimalReflection()));
}
}
public void Add_ShouldCallAddOnBookRepository_WhenValidArgumentsArePassed()
{
// Arrange
string authorFirstName = "test";
string authorLastName = "test";
string description = "test";
string title = "test";
string genreName = "test";
string Isbn = "9780307264787";
int pageCount = 15;
int yearOfPublish = 2000;
var genre = new Genre()
{
Name = genreName
};
var genreQuery = new List <Genre>()
{
genre
}
.AsQueryable();
var author = new Author()
{
FirstName = authorFirstName,
LastName = authorLastName
};
var authorQuery = new List <Author>()
{
author
}.AsQueryable();
var mockedBookRepo = new Mock <IEfRepostory <Book> >();
mockedBookRepo.Setup(b => b.Add(It.IsAny <Book>()));
var mockedGenreRepo = new Mock <IEfRepostory <Genre> >();
mockedGenreRepo.Setup(g => g.All).Returns(genreQuery);
var mockedAuthorRepo = new Mock <IEfRepostory <Author> >();
mockedAuthorRepo.Setup(g => g.All).Returns(authorQuery);
var sut = new BookService(mockedBookRepo.Object, mockedGenreRepo.Object, mockedAuthorRepo.Object);
//Act
sut.Add(authorFirstName, authorLastName, description, genreName, Isbn, pageCount, title,
yearOfPublish);
//Asssert
mockedBookRepo.Verify(x => x.Add(It.Is <Book>(b => b.ISBN == Isbn &&
b.Title == title &&
b.Authors.Contains(author) &&
b.Genres.Contains(genre) &&
b.Description == description &&
b.YearOfPublishing == yearOfPublish &&
b.ISBN == Isbn &&
b.PageCount == pageCount)), Times.Once);
}
public void Book_TestSystemIntegrationSql_SaveBook_ShouldBeOk()
{
Book BookToSave = ObjectMother.GetBookOK();
Book BookSaved = _bookService.Add(BookToSave);
Book resultadoEncontrado = _bookService.Get(BookSaved.Id);
BookSaved.Should().NotBeNull();
resultadoEncontrado.Id.Should().Be(BookSaved.Id);
BookSaved.Title.Should().Be(BookToSave.Title);
}
public int Add([Required][FromBody] AddBookDto dto)
{
return(_service.Add(dto));
}
public async Task Add_Test_PublisherDoesNotYetExist()
{
// arrange
var fakeUowProvider = A.Fake <IUnitOfWorkProvider>();
var fakeUow = A.Fake <IUnitOfWork>();
A.CallTo(() => fakeUowProvider.Get()).Returns(fakeUow);
var fakeRepoProvider = A.Fake <IBookRepositoryProvider>();
var fakeRepo = A.Fake <IBookRepository>();
A.CallTo(() => fakeRepo.GetIdByTitle("new_book")).Returns(1);
A.CallTo(() => fakeRepoProvider.Get(fakeUow)).Returns(fakeRepo);
var fakeTagRepoProvider = A.Fake <ITagRepositoryServiceProvider>();
var fakeTagRepo = A.Fake <ITagRepository>();
A.CallTo(() => fakeTagRepo.ExistsWithName("new_tag")).Returns(false);
A.CallTo(() => fakeTagRepo.ExistsWithName("existing_tag")).Returns(true);
A.CallTo(() => fakeTagRepoProvider.Get(fakeUow)).Returns(fakeTagRepo);
var fakePublisherRepoProvider = A.Fake <IPublisherRepositoryProvider>();
var fakePublisherRepo = A.Fake <IPublisherRepository>();
A.CallTo(() => fakePublisherRepo.ExistsWithName("some_publisher")).Returns(false);
A.CallTo(() => fakePublisherRepo.GetIdByName("some_publisher")).Returns(1);
A.CallTo(() => fakePublisherRepoProvider.Get(fakeUow)).Returns(fakePublisherRepo);
var fakeAuthorRepoProvider = A.Fake <IAuthorRepositoryProvider>();
var fakeAuthorRepo = A.Fake <IAuthorRepository>();
A.CallTo(() => fakeAuthorRepo.AuthorExists("John", "Smith")).Returns(false);
A.CallTo(() => fakeAuthorRepo.GetIdByName("John", "Smith")).Returns(2);
A.CallTo(() => fakeAuthorRepo.AuthorExists("Jane", "Doe")).Returns(true);
A.CallTo(() => fakeAuthorRepo.GetIdByName("Jane", "Doe")).Returns(1);
A.CallTo(() => fakeAuthorRepoProvider.Get(fakeUow)).Returns(fakeAuthorRepo);
Publisher publisher = new Publisher {
Name = "some_publisher"
};
BookService service = new BookService(fakeUowProvider, fakeRepoProvider, fakePublisherRepoProvider, fakeAuthorRepoProvider, fakeTagRepoProvider);
Tag newTag = new Tag {
Id = 1, Name = "new_tag"
};
Tag existingTag = new Tag {
Id = 2, Name = "existing_tag"
};
Author newAuthor = new Author {
Id = 2, FirstName = "John", LastName = "Smith"
};
Author existingAuthor = new Author {
Id = 1, FirstName = "Jane", LastName = "Doe"
};
Book book = new Book
{
Id = 1,
Title = "new_book",
Publisher = publisher,
Tags = new List <Tag>
{
newTag,
existingTag
},
Authors = new List <Author>
{
newAuthor,
existingAuthor
}
};
// act
await service.Add(book);
// assert
A.CallTo(() => fakeUow.Begin()).MustHaveHappened();
Assert.AreEqual(1, book.Publisher.Id);
A.CallTo(() => fakePublisherRepo.Create(book.Publisher)).MustHaveHappened();
A.CallTo(() => fakeRepo.Create(book)).MustHaveHappened();
A.CallTo(() => fakeTagRepo.Create(newTag)).MustHaveHappened();
A.CallTo(() => fakeTagRepo.LinkMediaItem(1, 1));
A.CallTo(() => fakeTagRepo.LinkMediaItem(1, 2));
A.CallTo(() => fakeAuthorRepo.Create(newAuthor)).MustHaveHappened();
A.CallTo(() => fakeAuthorRepo.LinkBook(1, 1)).MustHaveHappened();
A.CallTo(() => fakeAuthorRepo.LinkBook(1, 2)).MustHaveHappened();
A.CallTo(() => fakeUow.Commit()).MustHaveHappened();
}
public async Task <ActionResult <Book> > PostBook(Book book)
{
await _service.Add(book);
return(Ok());
}
public JsonResponse AddBook(Book model)
{
return(service.Add(model));
}
public JsonResult Add()
{
serv.Add();
return(Json(true));
}
public ActionResult Add(Book tempBook)
{
library.Add(tempBook);
return(RedirectToAction("Show"));
}
