moviewyrm/bookwyrm/tests/models/test_import_model.py

""" testing models """
import datetime
import json
import pathlib
from unittest.mock import patch

from django.utils import timezone
from django.test import TestCase
import responses

from bookwyrm import models
from bookwyrm.book_search import SearchResult
from bookwyrm.connectors import connector_manager


class ImportJob(TestCase):
    """this is a fancy one!!!"""

    def setUp(self):
        """data is from a goodreads export of The Raven Tower"""
        read_data = {
            "Book Id": 39395857,
            "Title": "The Raven Tower",
            "Author": "Ann Leckie",
            "Author l-f": "Leckie, Ann",
            "Additional Authors": "",
            "ISBN": '="0356506991"',
            "ISBN13": '="9780356506999"',
            "My Rating": 0,
            "Average Rating": 4.06,
            "Publisher": "Orbit",
            "Binding": "Hardcover",
            "Number of Pages": 416,
            "Year Published": 2019,
            "Original Publication Year": 2019,
            "Date Read": "2019/04/12",
            "Date Added": "2019/04/09",
            "Bookshelves": "",
            "Bookshelves with positions": "",
            "Exclusive Shelf": "read",
            "My Review": "",
            "Spoiler": "",
            "Private Notes": "",
            "Read Count": 1,
            "Recommended For": "",
            "Recommended By": "",
            "Owned Copies": 0,
            "Original Purchase Date": "",
            "Original Purchase Location": "",
            "Condition": "",
            "Condition Description": "",
            "BCID": "",
        }
        currently_reading_data = read_data.copy()
        currently_reading_data["Exclusive Shelf"] = "currently-reading"
        currently_reading_data["Date Read"] = ""

        unknown_read_data = currently_reading_data.copy()
        unknown_read_data["Exclusive Shelf"] = "read"
        unknown_read_data["Date Read"] = ""

        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch(
            "bookwyrm.activitystreams.populate_stream_task.delay"
        ):
            user = models.User.objects.create_user(
                "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
            )
        job = models.ImportJob.objects.create(user=user)
        self.item_1 = models.ImportItem.objects.create(
            job=job, index=1, data=currently_reading_data
        )
        self.item_2 = models.ImportItem.objects.create(job=job, index=2, data=read_data)
        self.item_3 = models.ImportItem.objects.create(
            job=job, index=3, data=unknown_read_data
        )

    def test_isbn(self):
        """it unquotes the isbn13 field from data"""
        expected = "9780356506999"
        item = models.ImportItem.objects.get(index=1)
        self.assertEqual(item.isbn, expected)

    def test_shelf(self):
        """converts to the local shelf typology"""
        expected = "reading"
        self.assertEqual(self.item_1.shelf, expected)

    def test_date_added(self):
        """converts to the local shelf typology"""
        expected = datetime.datetime(2019, 4, 9, 0, 0, tzinfo=timezone.utc)
        item = models.ImportItem.objects.get(index=1)
        self.assertEqual(item.date_added, expected)

    def test_date_read(self):
        """converts to the local shelf typology"""
        expected = datetime.datetime(2019, 4, 12, 0, 0, tzinfo=timezone.utc)
        item = models.ImportItem.objects.get(index=2)
        self.assertEqual(item.date_read, expected)

    def test_currently_reading_reads(self):
        """infer currently reading dates where available"""
        expected = [
            models.ReadThrough(
                start_date=datetime.datetime(2019, 4, 9, 0, 0, tzinfo=timezone.utc)
            )
        ]
        actual = models.ImportItem.objects.get(index=1)
        self.assertEqual(actual.reads[0].start_date, expected[0].start_date)
        self.assertEqual(actual.reads[0].finish_date, expected[0].finish_date)

    def test_read_reads(self):
        """infer read dates where available"""
        actual = self.item_2
        self.assertEqual(
            actual.reads[0].start_date,
            datetime.datetime(2019, 4, 9, 0, 0, tzinfo=timezone.utc),
        )
        self.assertEqual(
            actual.reads[0].finish_date,
            datetime.datetime(2019, 4, 12, 0, 0, tzinfo=timezone.utc),
        )

    def test_unread_reads(self):
        """handle books with no read dates"""
        expected = []
        actual = models.ImportItem.objects.get(index=3)
        self.assertEqual(actual.reads, expected)

    @responses.activate
    def test_get_book_from_isbn(self):
        """search and load books by isbn (9780356506999)"""
        connector_info = models.Connector.objects.create(
            identifier="openlibrary.org",
            name="OpenLibrary",
            connector_file="openlibrary",
            base_url="https://openlibrary.org",
            books_url="https://openlibrary.org",
            covers_url="https://covers.openlibrary.org",
            search_url="https://openlibrary.org/search?q=",
            priority=3,
        )
        connector = connector_manager.load_connector(connector_info)
        result = SearchResult(
            title="Test Result",
            key="https://openlibrary.org/works/OL1234W",
            author="An Author",
            year="1980",
            connector=connector,
        )

        datafile = pathlib.Path(__file__).parent.joinpath("../data/ol_edition.json")
        bookdata = json.loads(datafile.read_bytes())
        responses.add(
            responses.GET,
            "https://openlibrary.org/works/OL1234W",
            json=bookdata,
            status=200,
        )
        responses.add(
            responses.GET,
            "https://openlibrary.org/works/OL15832982W",
            json=bookdata,
            status=200,
        )
        responses.add(
            responses.GET,
            "https://openlibrary.org/authors/OL382982A",
            json={"name": "test author"},
            status=200,
        )

        with patch("bookwyrm.connectors.abstract_connector.load_more_data.delay"):
            with patch(
                "bookwyrm.connectors.connector_manager.first_search_result"
            ) as search:
                search.return_value = result
                with patch(
                    "bookwyrm.connectors.openlibrary.Connector." "get_authors_from_data"
                ):
                    book = self.item_1.get_book_from_isbn()

        self.assertEqual(book.title, "Sabriel")