Example #1
0
    def test_delete(self):
        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        deleted = series.delete()
        self.assertIsNone(series.id)
        self.assertEquals((1, {"series.Series": 1}), deleted)

        series, created = Series.from_dict({
            "name":
            "Secret Files",
            "links": [{
                "url": "https://secrectfiles.com"
            }]
        })
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        deleted = series.delete()
        self.assertIsNone(series.id)
        self.assertEquals(
            (3, {
                "series.Series": 1,
                "series.Series_links": 1,
                "links.Link": 1
            }),
            deleted,
        )
Example #2
0
    def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
        """Create from dict.

        Returns True if was crated, i. e. was not found in the DB.
        """
        defaults: Dict = {}
        if "series" in data and data["series"]:
            defaults["series"] = Series.from_dict(data["series"])[0]
        if "volume" in data and data["volume"]:
            defaults["volume"] = data["volume"]

        book, created = Book.objects.get_or_create(title=data["title"],
                                                   defaults=defaults)

        if "authors" in data and data["authors"]:
            for i in data["authors"]:
                book.authors.add(Person.from_dict(i)[0])
        if "genres" in data and data["genres"]:
            for i in data["genres"]:
                book.genres.add(Genre.from_dict(i)[0])
        if "links" in data and data["links"]:
            for i in data["links"]:
                book.links.add(Link.from_dict(i)[0])

        return book, created
Example #3
0
    def test_search(self):
        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        series, created = Series.from_dict({"name": "Ran"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        series, created = Series.from_dict({"name": "Random Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        self.assertEquals(3, Series.objects.all().count())
        self.assertEquals(2, Series.search("files").count())
        self.assertEquals(2, Series.search("ran").count())
Example #4
0
    def test_from_to_dict(self):
        link, created = Link.objects.get_or_create(
            link="https://secrectfiles.com")
        self.assertTrue(created)
        self.assertIsNotNone(link.id)

        series, created = Series.objects.get_or_create(name="Secret Files")
        series.links.add(link)
        self.assertTrue(created)
        self.assertIsNotNone(series.id)
        self.assertEquals(
            {
                "name": "Secret Files",
                "links": [{
                    "url": "https://secrectfiles.com"
                }]
            },
            series.to_dict(),
        )
        self.assertEquals(
            (series, False),
            Series.from_dict({
                "name": "Secret Files",
                "links": [{
                    "url": "https://secrectfiles.com"
                }]
            }),
        )
        self.assertEquals((series, False),
                          Series.from_dict({"name": "Secret Files"}))

        series, created = Series.objects.get_or_create(name="Random")
        self.assertTrue(created)
        self.assertIsNotNone(series.id)
        self.assertEquals({"name": "Random", "links": None}, series.to_dict())
        self.assertEquals((series, False),
                          Series.from_dict({
                              "name": "Random",
                              "links": None
                          }))
        self.assertEquals((series, False), Series.from_dict({"name":
                                                             "Random"}))
Example #5
0
    def test_get(self):
        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        series2 = Series.get("Secret Files")
        self.assertIsNotNone(series2)
        self.assertEquals(series, series2)

        series2 = Series.get("files")
        self.assertIsNotNone(series2)
        self.assertEquals(series, series2)

        series2 = Series.get(str(series.id))
        self.assertIsNotNone(series2)
        self.assertEquals(series, series2)
Example #6
0
    def test_get_or_create(self):
        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)
        self.assertEquals(1, Series.objects.count())

        series2 = Series.get_or_create("Secret Files")
        self.assertIsNotNone(series2)
        self.assertEquals(series, series2)
        self.assertEquals(1, Series.objects.count())

        series2 = Series.get_or_create(str(series.id))
        self.assertIsNotNone(series2)
        self.assertEquals(series, series2)
        self.assertEquals(1, Series.objects.count())

        series2 = Series.get_or_create("Secret Papers")
        self.assertIsNotNone(series2)
        self.assertNotEquals(series, series2)
        self.assertEquals(2, Series.objects.count())
Example #7
0
    def test_print(self):
        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        with StringIO() as cout:
            series.print(cout)
            self.assertEquals(
                "Field                            Value                              "
                +
                "                                \n=================================="
                +
                "==================================================================\n"
                +
                "Id                               1                                  "
                +
                "                                \n__________________________________"
                +
                "__________________________________________________________________\n"
                +
                "Name                             Secret Files                       "
                +
                "                                \n__________________________________"
                +
                "__________________________________________________________________\n"
                +
                "Links                                                               "
                +
                "                                \n__________________________________"
                +
                "__________________________________________________________________\n"
                +
                "Books                                                               "
                +
                "                                \n__________________________________"
                +
                "__________________________________________________________________\n",
                cout.getvalue(),
            )
Example #8
0
    def test_from_to_dict(self):
        book, created = Book.objects.get_or_create(title="Cool")
        self.assertTrue(created)
        self.assertIsNotNone(book.id)
        self.assertEquals(
            {
                "title": "Cool",
                "authors": None,
                "series": None,
                "volume": 0,
                "genres": None,
                "links": None,
            },
            book.to_dict(),
        )
        self.assertEquals((book, False), Book.from_dict(book.to_dict()))
        self.assertEquals((book, False), Book.from_dict({"title": "Cool"}))

        author, created = Person.from_dict({"name": "Max Mustermann"})
        self.assertTrue(created)
        self.assertIsNotNone(author.id)

        series, created = Series.from_dict({"name": "Secret Files"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        genre, created = Genre.from_dict({"name": "Fiction"})
        self.assertTrue(created)
        self.assertIsNotNone(genre.id)

        link, created = Link.from_dict({"url": "https://example.com"})
        self.assertTrue(created)
        self.assertIsNotNone(link.id)

        book, created = Book.objects.get_or_create(title="Example",
                                                   series=series,
                                                   volume=1)
        book.authors.add(author)
        book.genres.add(genre)
        book.links.add(link)
        self.assertTrue(created)
        self.assertIsNotNone(book.id)
        self.assertEquals(
            {
                "title": "Example",
                "authors": [{
                    "name": "Max Mustermann",
                    "links": None
                }],
                "series": {
                    "name": "Secret Files",
                    "links": None
                },
                "volume": 1,
                "genres": [{
                    "name": "Fiction"
                }],
                "links": [{
                    "url": "https://example.com"
                }],
            },
            book.to_dict(),
        )
        self.assertEquals((book, False), Book.from_dict(book.to_dict()))
Example #9
0
    def test_edit(self):
        series, created = Series.from_dict({"name": "Test Series"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        person, created = Person.from_dict({"name": "John Do"})
        self.assertTrue(created)
        self.assertIsNotNone(person.id)

        book, created = Book.from_dict({
            "title": "Test2 Book",
            "authors": [person.to_dict()],
            "series": series.to_dict(),
            "volume": 1.0,
            "genres": [{
                "name": "Romance"
            }],
        })
        self.assertTrue(created)
        self.assertIsNotNone(book.id)
        self.assertEquals(series, book.series)
        self.assertEquals(person, book.authors.first())

        book.edit("title", "IEEE Test Book")
        self.assertEquals("IEEE Test Book", book.title)

        book.edit("author", "Jane Do")
        self.assertEquals(2, book.authors.count())
        self.assertEquals("Jane Do", str(book.authors.all()[0]))
        self.assertEquals("John Do", str(book.authors.all()[1]))

        book.edit("author", str(person.id))
        self.assertEquals(1, book.authors.count())
        self.assertEquals("Jane Do", str(book.authors.all()[0]))

        series, created = Series.from_dict({"name": "Space Series"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        book.edit("series", str(series.id))
        self.assertEquals(series, book.series)

        book.edit("volume", 0.75)
        self.assertEquals(0.75, book.volume)

        series, created = Series.from_dict({"name": "Deep Space Series"})
        self.assertTrue(created)
        self.assertIsNotNone(series.id)

        book.edit("series", "Deep Space")
        self.assertEquals(series, book.series)

        book.edit("genre", "SciFi")
        self.assertEquals(2, book.genres.count())
        self.assertEquals("Romance", book.genres.first().name)
        self.assertEquals("SciFi", book.genres.last().name)

        book.edit("genre", "1")
        self.assertEquals(1, book.genres.count())
        self.assertEquals("SciFi", book.genres.first().name)

        book.edit("link", "https://deep.space")
        self.assertEquals(1, book.links.count())
        self.assertEquals("https://deep.space", book.links.first().link)

        book.edit("link", "https://janedo.com/test2book")
        self.assertEquals(2, book.links.count())
        self.assertEquals("https://janedo.com/test2book",
                          book.links.last().link)

        book.edit("link", "https://deep.space")
        self.assertEquals(1, book.links.count())
        self.assertEquals("https://janedo.com/test2book",
                          book.links.first().link)
Example #10
0
def _series(args: Namespace, file: TextIO = sys.stdout):
    series: Optional[Series] = None
    if args.subparser == "add":
        series, created = Series.from_dict({
            "name":
            args.name,
            "links":
            [Link.get_or_create(link).to_dict() for link in args.link],
        })
        if created:
            stdout.write(
                _('Successfully added series "%(name)s" with id "%(pk)d".') % {
                    "name": series.name,
                    "pk": series.pk
                },
                "=",
                file=file,
            )
            series.print(file)
        else:
            stdout.write(
                _('The series "%(name)s" already exists with id "%(pk)d", aborting...'
                  ) % {
                      "name": series.name,
                      "pk": series.pk
                  },
                "",
                file=file,
            )
    elif args.subparser == "delete":
        series = Series.get(args.series)
        if series:
            series.delete()
            stdout.write(
                _('Successfully deleted series with id "%(pk)d".') %
                {"pk": series.pk},
                "",
                file=file,
            )
        else:
            stdout.write(_("No series found."), "", file=file)
    elif args.subparser == "edit":
        series = Series.get(args.series)
        if series:
            series.edit(args.field, args.value)
            stdout.write(
                _('Successfully edited series "%(name)s" with id "%(pk)d".') %
                {
                    "name": series.name,
                    "pk": series.pk
                },
                "",
                file=file,
            )
            series.print(file)
        else:
            stdout.write(_("No series found."), "", file=file)
    elif args.subparser == "info":
        series = Series.get(args.series)
        if series:
            series.print(file)
        else:
            stdout.write(_("No series found."), "", file=file)
    elif args.subparser == "list":
        if args.search:
            series = Series.search(args.search)
        else:
            series = Series.objects.all()
        stdout.write(
            [_("Id"), _("Name"), _("Number of books")],
            "=", [0.05, 0.8],
            file=file)
        for i, has_next in lookahead(series):
            stdout.write(
                [i.id, i.name, i.books.count()],
                "_" if has_next else "=",
                [0.05, 0.8],
                file=file,
            )