Example #1
0
    def setUp(self):
        self.validator = Validator()
        self.book = Book(12, '', '', '')
        self.book2 = Book(22, 'da', 'desc', 'aut')

        self.client = Client(13, '')
        self.client2 = Client(14, 'da')
    def testRepositoryClients(self):
        repoClient = Repository()
        client = Client(1, "Name")
        client1 = Client(2, "Name1")

        self.assertTrue(repoClient.size() == 0)
        repoClient.add(client)
        self.assertTrue(repoClient.size() == 1)
        repoClient.add(client1)

        self.assertTrue(repoClient.existsById(1))
        self.assertTrue(repoClient.existsById(2))
        self.assertTrue(repoClient.getById(1).getName() == "Name")

        repoClient.removeById(1)
        self.assertTrue(repoClient.size() == 1)
        repoClient.remove(client1)
        self.assertTrue(repoClient.size() == 0)

        self.assertTrue(repoClient.existsById(1) == False)

        repoClient.add(client)
        repoClient.update(Client(1, "Updated Name"))

        self.assertTrue(repoClient.findById(1) == 0)
        self.assertTrue(repoClient.getById(1).getName() == "Updated Name")

        self.assertTrue(str(repoClient.getById(1)) == "CLIENT ID: " + str(
            repoClient.getById(1).getId()) + "| Name: " + repoClient.getById(1).getName())
Example #3
0
def testRentalRepository():
    rentalRepo = Repository()
    book1 = Book(0, "The Q", "Albert", "Heinrich")
    book2 = Book(1, "The D", "Elbert", "Reinsich")
    client1 = Client(0, "Mihai", 1854987548795)
    client2 = Client(1, "Alex", 1987548759658)

    rentalRepo.addElement(Rental(1, book1, 0))
    rentalRepo.addElement(Rental(0, book2, 1))

    # _find(_id) returns the Rental from the repository
    # that has the client Id equal to _id

    assert rentalRepo._find(0).getRentedBook() == book1 
    assert rentalRepo._find(1).getId() == 1

    assert rentalRepo._find(1).getRentedBook() == book2
    assert rentalRepo._find(0).getId() == 0

    # findId() function for Repository class
    assert rentalRepo.findId(12) == False
    assert rentalRepo.findId(0) == True

    # elementFromId()
    assert rentalRepo.elementFromId(0).getRentedBook() == book1

    rentalRepo.addElement(Rental(1, book2, 2)) 

    print ("Rental repository tests ran successfully!")
Example #4
0
    def testRentalRepository(self):
        rentalRepo = Repository()
        book1 = Book(0, "The Q", "Albert", "Heinrich")
        book2 = Book(1, "The D", "Elbert", "Reinsich")
        client1 = Client(0, "Mihai", 1854987548795)
        client2 = Client(1, "Alex", 1987548759658)

        rentalRepo.addElement(Rental(1, book1, 0))
        rentalRepo.addElement(Rental(0, book2, 1))

        # _find(_id) returns the Rental from the repository
        # that has the client Id equal to _id

        self.assertEqual(rentalRepo._find(0).getRentedBook(), book1)
        self.assertEqual(rentalRepo._find(1).getId(), 1)

        self.assertEqual(rentalRepo._find(1).getRentedBook(), book2)
        self.assertEqual(rentalRepo._find(0).getId(), 0)

        # findId() function for Repository class
        self.assertEqual(rentalRepo.findId(12), False)
        self.assertEqual(rentalRepo.findId(0), True)

        # elementFromId()
        self.assertEqual(rentalRepo.elementFromId(0).getRentedBook(), book1)

        rentalRepo.addElement(Rental(1, book2, 2))
    def setUp(self):
        self.repo = Repository()
        self.brepo = Repository()
        self.crepo = Repository()
        self.Ucontroller = UndoController()
        self.book = Book(21, 'titlu', 'descriere', 'author')
        self.book2 = Book(22, 'titlu2', 'descriere2', 'author')
        self.brepo.add(self.book)
        self.brepo.add(self.book2)
        self.client = Client(23, 'alex')
        self.client2 = Client(24, 'ana')
        self.client3 = Client(29, 'ana')

        self.crepo.add(self.client)
        self.crepo.add(self.client2)
        self.rental = Rental(21236, 21, 24, date(2017, 11, 5),
                             date(2017, 12, 6), date(2017, 12, 5))
        self.rental2 = Rental(21238, 22, 24, date(2017, 11, 5),
                              date(2017, 12, 6), date(2017, 12, 5))
        self.rental3 = Rental(21238, 23, 24, date(2017, 11, 5),
                              date(2017, 12, 6), date(2017, 12, 5))
        self.rental4 = Rental(21238, 21, 29, date(2017, 11, 5),
                              date(2017, 12, 6), date(2017, 12, 5))
        self.rental5 = Rental(21231, 21, 23, date(2017, 11, 5),
                              date(2017, 10, 6), None)

        self.controller = RentalController(self.repo, self.brepo, self.crepo,
                                           self.Ucontroller)
        self.ceva = LateRentalCount(12, 32)
        self.altceva = BookRentalCount(12, 23)
        self.nu = AuthorRentalCount('da', 23)
        self.da = ClientRentalCount(32, 12)
Example #6
0
 def setUp(self):
     self.client = Client(23, 'alex')
     self.client2 = Client(12, 'diana')
     self.book = Book(21, 'titlu', 'descriere', 'author')
     self.book2 = Book(22, 'titlu2', 'descriere2', 'author2')
     self.rental = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
     self.rental2 = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
 def setUp(self):
     self.repo = Repository()
     self.rentalRepo = Repository()
     self.Ucontroller = UndoController()
     self.client = Client(11, 'alex')
     self.client2 = Client(12, 'ana')
     self.controller = ClientController(self.repo, self.Ucontroller,
                                        self.rentalRepo)
Example #8
0
 def test_creaza_client(self, nume, cnp) -> None:
     id = self.__ic.getNewClientId()
     client = Client(id, nume, cnp)
     assert (client.getId() == id)
     assert (client.getName() == nume)
     assert (client.getCnp() == cnp)
     self.__ic.updateLastClientId()
     self.__clientRepo.adauga_client(client, False)
Example #9
0
 def setUp(self):
     self.repo = Repository()
     self.c = Client(12, 'alex')
     self.c1 = Client(121, 'ana')
     self.repo2 = FileRepository('testclient.txt',
                                 Client.readClientFromLine,
                                 Client.writeClientToLine)
     self.repo3 = FileRepository('testclient4.txt',
                                 Client.readClientFromLine,
                                 Client.writeClientToLine)
    def testRepo(self):
        self.assertEqual(len(self._repo), 0)
        c = Client("1", "1840101223366", "Anna")
        self._repo.store(c)
        self.assertEqual(len(self._repo), 1)
        self.assertRaises(RepositoryException, self._repo.store, c)

        c = Client("2", "1840101223366", "Anna")
        self._repo.store(c)
        self.assertEqual(len(self._repo), 2)
        '''
Example #11
0
    def testClientRepository(self):

        repo = Repository()
        c1 = Client(1, "Alice", 6548987854215)
        c2 = Client(2, "Vlad", 1944444444444)

        self.assertEqual(len(repo), 0)

        repo.addElement(c1)
        self.assertEqual(len(repo), 1)
        repo.addElement(c2)
        self.assertEqual(len(repo), 2)
Example #12
0
def testClientRepository():
    
    repo = Repository()
    c1 = Client(1, "Alice", 6548987854215)
    c2 = Client(2, "Vlad", 1944444444444)

    assert len(repo) == 0

    repo.addElement(c1)
    assert len(repo) == 1
    repo.addElement(c2)
    assert len(repo) == 2


    print ("ClientRepository tests ran successfully!")
    def __loadFromFile(self, type):
        """
        :param sample: Element
        :return: None
        :raises RepositoryException when the file cannot be read for some reason
        """
        try:
            f = open(self.__fileName, "r")
            line = f.readline().strip()
            while line != "":
                attrs = line.split(",")

                if type == Book:
                    book = Book(int(attrs[0]), attrs[1], attrs[2], attrs[3])
                    self.__repo.add(book)
                    line = f.readline().strip()

                if type == Client:
                    client = Client(int(attrs[0]), attrs[1])
                    self.__repo.add(client)
                    line = f.readline().strip()

                if type == Rental:
                    rental = Rental(
                        int(attrs[0]), int(attrs[1]), int(attrs[2]),
                        createDateFromString(self.__reverseDate(attrs[3])),
                        createDateFromString(self.__reverseDate(attrs[4])),
                        createDateFromString(self.__reverseDate(attrs[5])))
                    self.__repo.add(rental)
                    line = f.readline().strip()
        except IOError:
            raise RepositoryException()
        finally:
            f.close()
Example #14
0
class TestRepository(unittest.TestCase):
    def setUp(self):
        self.repo = Repository()
        self.c = Client(12, 'alex')
        self.c1 = Client(121, 'ana')
        self.repo2 = FileRepository('testclient.txt',
                                    Client.readClientFromLine,
                                    Client.writeClientToLine)
        self.repo3 = FileRepository('testclient4.txt',
                                    Client.readClientFromLine,
                                    Client.writeClientToLine)

    def test_repo(self):
        self.assertEqual(len(self.repo), 0)
        self.repo.add(self.c)
        self.assertEqual(str(self.repo), '012. alex\n\n')
        self.assertEqual(len(self.repo), 1)
        self.assertRaises(RepositoryException, self.repo.add, self.c)
        self.assertEqual(len(self.repo.getAll()), 1)
        self.assertEqual(self.repo.findByID(12), 12)
        self.assertEqual(self.repo.findByID(13), -1)
        self.assertEqual(self.repo.get(12), self.c)
        self.assertRaises(RepositoryException, self.repo.get, 13)
        self.assertRaises(RepositoryException, self.repo.remove, 13)
        self.assertRaises(RepositoryException, self.repo.update, 13)
        self.repo.update(self.c)
        self.repo.remove(12)
        self.assertEqual(len(self.repo), 0)
        self.repo2.add(self.c)
        self.repo2.upd(self.c)
        self.repo2.rem(self.c.getID())
        self.assertEqual(len(self.repo2), 1)
 def test_add(self):
     '''
     testing the add function of both client repo and book repo + rent repo
     also testing return function for rent
     '''
     book1 = Book(0, "Persona 3", "3rd entry in the series", "Shuji Sogabe")
     self._book_repo.add(book1)
     listBooks = self._book_repo.getAll()
     assert len(listBooks) == 1
     assert listBooks[0].get_title() == "Persona 3"
     assert listBooks[0].get_author() == "Shuji Sogabe"
     assert listBooks[0].get_desc() == "3rd entry in the series"
     assert listBooks[0].get_id() == 0
     client1 = Client(1, "Scott Fitzgerald")
     self._client_repo.add(client1)
     listClients = self._client_repo.getAll()
     assert len(listClients) == 1
     assert listClients[0].get_name() == "Scott Fitzgerald"
     self._rental_repo.rent_book(client1, book1, datetime(2018, 11, 3))
     listRent = self._rental_repo.getAll()
     assert len(listRent) == 1
     assert listRent[0].get_clientID() == 1
     assert listRent[0].get_bookID() == 0
     assert listRent[0].get_rentalID() == 0
     assert str(listRent[0].get_rented_date()) == "2018-11-03 00:00:00"
     assert str(listRent[0].get_due_date()) == "2018-11-17 00:00:00"
     assert str(listRent[0].get_return_date()) == "None"
     self._rental_repo.return_book(client1, book1, datetime(2018, 12, 3))
     assert str(listRent[0].get_return_date()) == "2018-12-03 00:00:00"
 def test_add(self):
     '''
     tests the add function for client and book controller and rent function for rental service
     also the return function for rental service
     '''
     book = Book(0, "Persona 3", "3rd entry in the series", "Shuji Sogabe")
     self._controller.add_book(book)
     listBooks = self._controller._book_repo.getAll()
     assert len(listBooks) == 1
     assert listBooks[0].get_title() == "Persona 3"
     assert listBooks[0].get_author() == "Shuji Sogabe"
     assert listBooks[0].get_desc() == "3rd entry in the series"
     assert listBooks[0].get_id() == 0
     client1 = Client(1, "Scott Fitzgerald")
     self._controller.add_client(client1)
     listClients = self._controller._client_repo.getAll()
     assert len(listClients) == 1
     assert listClients[0].get_name() == "Scott Fitzgerald"
     self._service.rent(book, client1, datetime(2018, 11, 3))
     listRent = self._service._rent_repo.getAll()
     assert len(listRent) == 2
     assert listRent[0].get_clientID() == 1
     assert listRent[0].get_bookID() == 0
     assert listRent[0].get_rentalID() == 0
     assert str(listRent[0].get_rented_date()) == "2018-11-03 00:00:00"
     assert str(listRent[0].get_due_date()) == "2018-11-17 00:00:00"
     assert str(listRent[0].get_return_date()) == "None"
     self._service.return_book(book, client1, datetime(2018, 12, 3))
     listRent = self._service._rent_repo.getAll()
     assert str(listRent[0].get_return_date()) == "2018-12-03 00:00:00"
Example #17
0
    def testClientController(self):
        repo = Repository()
        contr = ClientController(repo)
        undoController = Undo()
        contr.addUndoController(undoController)

        self.assertEqual(contr.addClient(Client(1, "alice", 1111111111111)),
                         True)
 def _loadFile(self):
     f = open(self._fileName, "r")
     line = f.readline().strip()
     while len(line) > 2:
         tok = line.split(";")
         client = Client(int(tok[0]), tok[1])
         Repository.store(self, client)
         line = f.readline().strip()
Example #19
0
 def create(self, clientId, clientCNP, clientName):
     client = Client(clientId, clientCNP, clientName)
     self.__validator.validate(client)
     self.__repository.store(client)
     undo = FunctionCall(self.delete, clientId)
     redo = FunctionCall(self.create, clientId, clientCNP, clientName)
     op = Operation(undo, redo)
     self._undoController.recordOperation(op)
     return client
Example #20
0
 def create(self, clientId, cnp, name):
     client = Client(clientId, cnp, name)
     self._validator.validate(client)
     self._repository.store(client)
     '''
     If the operation did not raise an Exception, then we record it for Undo/Redo
     '''
     self._operations.append(AddOperation(client))
     self._index += 1
     self._undoController.recordUpdatedControllers([self])
Example #21
0
    def create(self, clientID, clientName):
        client = Client(clientID, clientName)
        self.__validator.validate(client)
        self.__repository.add(client)

        undo = FunctionCall(self.remove, clientID)
        redo = FunctionCall(self.create, clientID, clientName)
        oper = Operation(undo, redo)
        self.__undo.addOperation(oper)
        return client
Example #22
0
    def add(self, name):
        client = Client(len(self.getAll()) * 29 + 55 * 22, name)
        self.__validator.validate(client)
        self.__repository.add(client)

        undo = FunctionCall(self.remove, self.searchByName(name)[0].id)
        redo = FunctionCall(self.create, self.searchByName(name)[0].id, name)
        oper = Operation(undo, redo)
        self.__undo.addOperation(oper)
        return True
 def testClient(self):
     self.assertTrue(self.v.validate, self.c)
     self.c.name = "bbb"
     self.assertTrue(self.v.validate, self.c.name == "bbb")
     self.c.name = ""
     self.assertRaises(ValidatorException, self.v.validate, self.c)
     z = Client("1", "Anna")
     self.client.add(z)
     self.client.remove(z)
     self.assertEqual(len(self.client.getAll()), 0)
Example #24
0
    def update(self, id, name):
        undo = FunctionCall(self.update, id, self.searchById(id)[0].name)
        client = Client(id, name)
        self.__validator.validate(client)
        self.__repository.update(client)

        redo = FunctionCall(self.update, id, name)
        oper = Operation(undo, redo)
        self.__undo.addOperation(oper)
        return True
Example #25
0
def testClientController():
    repo = Repository()
    contr = ClientController(repo)
    undoController = Undo()
    contr.addUndoController(undoController)

    assert contr.addClient(Client(1, "alice", 1111111111111)) == True


    print ("ClientController tests ran successfully!")
Example #26
0
 def adaugare_client(self, nume, cnp):
     #Functie folosita pentru adaugarea clientului
     #Date de intrare: nume String, cnp String (0 -> 9)
     #Date de iesire: -
     client = Client(self.__ic.getNewClientId(), nume, cnp)
     #Creezi o instanta a obiectului
     #Validezi
     self.__validare.validare_client(client, self.__repo.get_lista_clienti())
     self.__ic.updateLastClientId()
     #Actualizam ultimul ID daca nu a crapat
     #Adaugi la lista
     self.__repo.adauga_client(client)
Example #27
0
class TestDomain(unittest.TestCase):

    def setUp(self):
        self.ident = 23
        self.name = "alex"
        self.flight = "Tarom23"

    def test_something(self):
        self.client = Client(self.ident, self.name, self.flight)
        self.client2 = Client(12, "ana", "Tarom402")
        self.assertEqual(self.client.get_name(), "alex")
        self.assertNotEqual(self.client, self.client2)
Example #28
0
 def _loadFromFile(self):
     try:
         f = open(self._fName, "r")
     except IOError:
         return
     line = f.readline().strip()
     while line != "":
         t = line.split(";")
         c = Client(int(t[0]), t[1], t[2])
         Repository.store(self, c)
         line = f.readline().strip()
     f.close()
Example #29
0
    def create(self, clientId, clientCNP, clientName):
        client = Client(clientId, clientCNP, clientName)
        self.__repository.store(client)
        '''
        If the operation did not raise an Exception, then we record it for Undo/Redo
        '''
        redo = FunctionCall(self.create, clientId, clientCNP, clientName)
        undo = FunctionCall(self.delete, clientId)
        cascadeOp = CascadedOperation(Operation(redo, undo))
        self._undoController.recordOperation(cascadeOp)

        return client
    def testAddClient(self):
        client1 = Client(1, "Name1")
        client2 = Client(1, "Name2")
        repo = Repository()
        functions = ClientController(repo, Statistics(repo))

        msg1 = functions.addClient(client1.getId(), client1.getName())
        self.assertTrue(len(msg1) == 0)
        self.assertTrue(functions.getClients()[0].getId() == 1)

        msg2 = functions.addClient(client2.getId(), client2.getName())
        self.assertTrue(msg2 == "Cannot add an existing element")

        self.assertTrue(functions.getClients()[0].getId() == 1)
Example #31
0
def testClient():

    try:
        cli = Client(1, "Matthew", 1695454879852)  # object to test
        assert cli.getId() == 1
        assert cli.getName() == "Matthew"
        assert cli.getCnp() == 1695454879852

        cli.setName("Mastodon")
        cli.setCnp(1952354451235)

        assert cli.getId() == 1
        assert cli.getName() == "Mastodon"
        assert cli.getCnp() == 1952354451235
    except:
        assert False

    try:
        cli1 = Client("N", "na", 1955555555555)
        print(cli1)
        assert False
    except ClientException:
        pass

    try:
        cli1 = Client(1, "ok", 1952354451235)
        cli1.setName("(")
    except:
        pass

    try:
        cli1 = Client(1, "ok", 1952354451235)
        cli1.setCnp(-1)
    except:
        pass

    # at this point, constructor and getters should work.

    print("Client tests ran successfully!")
Example #32
0
 def testClient(self):
     
     try:
         cli = Client(1, "Matthew", 1695454879852) # object to test    
         self.assertEqual( cli.getId() ,  1 )
         self.assertEqual( cli.getName() ,  "Matthew" )
         self.assertEqual( cli.getCnp() ,  1695454879852 )
         
         cli.setName("Mastodon")
         cli.setCnp(1952354451235)
         
         self.assertEqual( cli.getId() ,  1 )
         self.assertEqual( cli.getName() ,  "Mastodon" )
         self.assertEqual( cli.getCnp() ,  1952354451235 )
     except:
         self.assertEqual( False )
     
     try:
         cli1 = Client("N", "na", 1955555555555)
         self.assertEqual( False )
     except ClientException:
         pass
     
     try:
         cli1 = Client(1, "ok", 1952354451235)
         cli1.setName("(")
     except:
         pass
     
     try:
         cli1 = Client(1, "ok", 1952354451235)
         cli1.setCnp(-1)
     except:
         pass