def map_raw_to_book(self, book_raw: Dict):
return Book(
**{
"id":
str(book_raw["_id"]) if "_id" in book_raw else None,
"title":
book_raw["title"] if "title" in book_raw else None,
"isbn":
book_raw["isbn"] if "isbn" in book_raw else None,
"page_count":
book_raw["page_count"] if "page_count" in book_raw else None,
"published_date":
book_raw["published_date"] if "published_date" in
book_raw else None,
"thumbnail_url":
book_raw["thumbnail_url"] if "thumbnail_url" in
book_raw else None,
"short_description":
book_raw["short_description"] if "short_description" in
book_raw else None,
"long_description":
book_raw["long_description"] if "long_description" in
book_raw else None,
"status":
book_raw["status"] if "status" in book_raw else None,
"authors":
book_raw["authors"] if "authors" in book_raw else None,
"categories":
book_raw["categories"] if "categories" in book_raw else None
})
def map_raw_to_book(self, book_raw: Dict):
return Book(
**{
"id":
str(self.is_key_in_dict(key="_id", book_raw=book_raw)),
"title":
self.is_key_in_dict(key="title", book_raw=book_raw),
"isbn":
self.is_key_in_dict(key="isbn", book_raw=book_raw),
"page_count":
self.is_key_in_dict(key="page_count", book_raw=book_raw),
"published_date":
self.is_key_in_dict(key="published_date", book_raw=book_raw),
"thumbnail_url":
self.is_key_in_dict(key="thumbnail_url", book_raw=book_raw),
"short_description":
self.is_key_in_dict(key="short_description",
book_raw=book_raw),
"long_description":
self.is_key_in_dict(key="long_description", book_raw=book_raw),
"status":
self.is_key_in_dict(key="status", book_raw=book_raw),
"authors":
self.is_key_in_dict(key="authors", book_raw=book_raw),
"categories":
self.is_key_in_dict(key="categories", book_raw=book_raw),
})
def read_input_file(input_file: str):
manager = DataManager("./gitignored_folder")
save_name = input_file.split("data")[1].replace(".txt",
"").replace("/", "")
data = manager.load_python_obj(save_name)
if data is None:
with open(input_file) as f:
# Read line 1
num_books, num_libs, max_days = map(
lambda x: int(x),
f.readline().strip().split(' '))
book_scores = list(
map(lambda x: int(x),
f.readline().strip().split(' ')))
books = []
for idx, elem in enumerate(book_scores):
books.append(Book(id=idx, score=elem))
book_score_list = np.asarray(book_scores)
book_scores = {x.id: x._score for x in books}
libs = []
for idx in range(num_libs):
# Read library stats
n_books_lib, signup_days, amount_of_books_per_day = map(
lambda x: int(x),
f.readline().strip().split(' '))
# Read books which are in that particular library
lib_books = list(
map(lambda x: int(x),
f.readline().strip().split(' ')))
lib_books = np.asarray(lib_books)
score_of_books_in_lib = book_score_list[lib_books]
sorted_indexes = sorted(range(len(score_of_books_in_lib)),
key=lambda k: score_of_books_in_lib[k])
sorted_books_based_on_score = lib_books[sorted_indexes]
sorted_books_based_on_score = np.flip(
sorted_books_based_on_score)
new_library = Library(
book_ids=sorted_books_based_on_score,
signup_days=signup_days,
amount_of_books_per_day=amount_of_books_per_day,
id=idx)
new_library.scores_sum = sum(
[book_scores[book_id] for book_id in lib_books])
libs.append(new_library)
manager.save_python_obj((num_books, num_libs, max_days, books, libs),
save_name)
return num_books, num_libs, max_days, books, libs
else:
return data
def test_on_success(self):
EXPECTED_SENDER = 'ANY_SENDER'
self.usecase.event = {'sender': {'id': EXPECTED_SENDER}}
book = Book()
self.usecase.on_success(book)
assert self.send_api_gateway.send_text_message.call_args[0][0] == EXPECTED_SENDER
def get_all_books(self) -> List[Book]:
sql = """SELECT * from book"""
cursor = connection.cursor()
cursor.execute(sql)
records = cursor.fetchall()
book_list = []
for book in records:
book = Book(book[0], book[5], book[1], book[2], book[3], book[4])
book_list.append(book)
return book_list
def get_book_by_id(self, book_id: int) -> Book:
sql = """SELECT * from book WHERE book_id = %s"""
cursor = connection.cursor()
cursor.execute(sql, [book_id])
records = cursor.fetchall()
book_list = []
for book in records:
book = Book(book[0], book[5], book[1], book[2], book[3], book[4])
book_list.append(book)
return book_list[0]
def get_book(self, gnucash_file):
xml_book = gnucash_file.find('gnc:book', self.ns)
book_id = xml_book.find('book:id', self.ns).text
book = self.book_repository.find_by_id(book_id)
if not book:
book = Book()
book.id = book_id
xml_comodity = xml_book.find('gnc:commodity', self.ns)
book.comodity = self.get_comodity(xml_comodity)
return book, xml_book
def test_import_url_success(self):
EXPECTED_URL = 'ANY_URL'
EXPECTED_BOOK = Book()
EXPECTED_ACCOUNT = Mock()
xml_account = Mock()
xml_book = Mock()
xml_book.findall = MagicMock(return_value=[xml_account])
self.http_client.get_from_url = MagicMock(return_value=Mock())
self.usecase.get_book = MagicMock(return_value=(EXPECTED_BOOK,
xml_book))
self.usecase.get_account = MagicMock(return_value=EXPECTED_ACCOUNT)
callback = Mock(ImportUrlCallback)
self.usecase.import_url(EXPECTED_URL, callback)
self.http_client.get_from_url.assert_called_with(EXPECTED_URL)
self.book_repository.update_or_create.assert_called_with(EXPECTED_BOOK)
callback.on_success.assert_called_with(EXPECTED_BOOK)
def addBook(self, bookId, title, author, description):
book = Book(bookId, title, author, description)
self.__validBook.validate(book)
self.__repoBook.storeBook(book)
from daos.book_dao_postgres import BookDaoPostgres
from entities.book import Book
book_dao = BookDaoPostgres()
test_book = Book(0,'Dracula','Bram Stoker',True,2,0)
class TestBookDAO:
def test_create_book(self):
book_dao.create_book(test_book)
assert test_book.book_id != 0
def test_get_by_id(self):
retrieved_book =book_dao.get_book_by_id(test_book.book_id)
assert test_book.title == retrieved_book.title
def test_update_book(self):
test_book.available = False
updated_book = book_dao.update_book(test_book)
assert updated_book.available == test_book.available
def test_delete_book(self):
result = book_dao.delete_book_by_id(test_book.book_id)
assert result == True
