Exemplo n.º 1
0
    def testSearchClient(self):
        self.clients = Repository()
        self.service = Service(self.clients, [], Repository())

        self.service.addClient(["John"])
        self.service.addClient(["Mike"])
        self.service.addClient(["zmaili"])
        self.service.addClient(["Johnny"])

        result = self.service.searchClients([2, True])
        self.assertEqual(result, [self.clients[2]])
        self.assertEqual(len(self.clients), 4)
        self.assertEqual(self.clients[2], Client(2, "Mike"))

        result = self.service.searchClients(["john", False])
        self.assertEqual(result, [self.clients[1], self.clients[4]])
        self.assertEqual(len(self.clients), 4)
        self.assertEqual(self.clients[1], Client(1, "John"))
        self.assertEqual(self.clients[4], Client(4, "Johnny"))

        result = self.service.searchClients(["luca", False])
        self.assertEqual(result, [])
        self.assertEqual(len(self.clients), 4)

        self.assertRaises(EmptyError, self.service.searchClients,
                          ["john", True])

        self.service.removeClient([2])
        self.assertRaises(EmptyError, self.service.searchClients, [2, True])

        result = self.service.searchClients([3, True])
        self.assertEqual(result, [self.clients[3]])
        self.assertEqual(len(self.clients), 3)
        self.assertEqual(self.clients[3], Client(3, "zmaili"))
Exemplo n.º 2
0
def main():
    '''
    Main function
    :return: the output file
    '''
    repository = Repository("Data/input.txt")
    repository.load_file()
    service = Service(repository)
    service.print_tsp(1)
    service.print_shortest_path()
Exemplo n.º 3
0
    def chooseClients(self):
        '''
        Randomly selects CLIENT_COUNT clients from a clientList 
        '''
        clientList = self.__getClients()
        random.shuffle(clientList)

        clientRepo = Repository()
        for i in range(self.count):
            clientRepo.increaseID()
            clientRepo + Client(clientRepo.ID, clientList[i])

        return clientRepo
Exemplo n.º 4
0
    def __reset(self):
        self.clients = Repository()
        self.movies = Repository()
        self.rentals = Repository()
        self.service = Service(self.clients, self.movies, self.rentals)

        self.service.addClient(["John"])
        self.service.addClient(["Mike"])
        self.service.addClient(["Nike"])

        self.service.addMovie(["Title1", "Desc1", "Genre1"])
        self.service.addMovie(["Title2", "Desc2", "Genre2"])
        self.service.addMovie(["Title3", "Desc3", "Genre3"])
Exemplo n.º 5
0
    def __init__(self, clients, movies):
        self.clients = clients
        self.movies = movies
        self.clientCount = len(self.clients)
        self.movieCount = len(self.movies)

        self.rentals = Repository()
        self.service = Service(self.clients, self.movies, self.rentals)
        self.val = Validator(self.clients, self.movies, self.rentals)
Exemplo n.º 6
0
    def chooseMovies(self):
        '''
        Randomly selects MOVIE_COUNT movies from a movieList
        @param:
            - None
        @return:
            - movieList = object of type MovieRepo
        '''
        movieList = self.__getMovies()
        random.shuffle(movieList)

        movieRepo = Repository()
        for i in range(self.count):
            movieRepo.increaseID()
            movieRepo + Movie(movieRepo.ID, movieList[i][0], movieList[i][1],
                              movieList[i][2])

        return movieRepo
Exemplo n.º 7
0
    def testSearchMovie(self):
        self.movies = Repository()
        self.service = Service([], self.movies, Repository())

        self.service.addMovie(["title1", "desc1", "genre1"])
        self.service.addMovie(["tiitle2", "deesc2", "geenre2"])
        self.service.addMovie(["title 3", "desc 3", "genre 3"])

        result = self.service.searchMovies(["title", False])
        self.assertEqual(result, [self.movies[1], self.movies[3]])
        self.assertEqual(len(self.movies), 3)
        self.assertEqual(self.movies[1], Movie(1, "title1", "desc1", "genre1"))
        self.assertEqual(self.movies[2],
                         Movie(2, "tiitle2", "deesc2", "geenre2"))
        self.assertEqual(self.movies[3],
                         Movie(3, "title 3", "desc 3", "genre 3"))

        result = self.service.searchMovies(["taitle", False])
        self.assertEqual(result, [])
        self.assertEqual(len(self.movies), 3)

        self.service.removeMovie([2])
        self.assertRaises(EmptyError, self.service.searchMovies, [2, True])

        self.assertRaises(EmptyError, self.service.searchMovies,
                          ["john", True])

        result = self.service.searchMovies([3, True])
        self.assertEqual(result, [self.movies[3]])
        self.assertEqual(len(self.movies), 2)
        self.assertEqual(self.movies[1], Movie(1, "title1", "desc1", "genre1"))
        self.assertEqual(self.movies[3],
                         Movie(3, "title 3", "desc 3", "genre 3"))

        result = self.service.searchMovies(["tITlE", False])
        self.assertEqual(result, [self.movies[1], self.movies[3]])
        self.assertEqual(len(self.movies), 2)
        self.assertEqual(self.movies[1], Movie(1, "title1", "desc1", "genre1"))
        self.assertEqual(self.movies[3],
                         Movie(3, "title 3", "desc 3", "genre 3"))
Exemplo n.º 8
0
    def testRent(self):
        self.rentals = Repository()
        self.service = Service(self.clients, self.movies, self.rentals)

        self.service.rentMovie([1, 1, date(2019, 11, 12), date(2019, 11, 15)])
        self.assertTrue(self.movies[1].isRented)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.rentals[1].rentDate, date(2019, 11, 12))
        self.assertEqual(self.rentals[1].dueDate, date(2019, 11, 15))
        self.assertEqual(self.rentals[1].clientID, 1)
        self.assertEqual(self.rentals[1].movieID, 1)

        self.service.rentMovie([2, 2, date(2019, 11, 12), date(2019, 11, 15)])
        self.assertTrue(self.movies[2].isRented)
        self.assertEqual(len(self.rentals), 2)
        self.assertEqual(self.rentals[2].rentDate, date(2019, 11, 12))
        self.assertEqual(self.rentals[2].dueDate, date(2019, 11, 15))
        self.assertEqual(self.rentals[2].clientID, 2)
        self.assertEqual(self.rentals[2].movieID, 2)
Exemplo n.º 9
0
    def testReturn(self):
        self.rentals = Repository()
        self.service = Service(self.clients, self.movies, self.rentals)

        self.service.rentMovie([1, 1, date(2019, 11, 12), date(2019, 11, 15)])
        self.service.rentMovie([2, 2, date(2019, 11, 12), date(2019, 11, 15)])
        self.service.rentMovie([3, 3, date(2019, 11, 12), date(2019, 11, 15)])
        self.service.rentMovie([4, 4, date(2019, 11, 12), date(2019, 11, 15)])

        self.service.returnMovie([1, 1, 1])
        self.assertFalse(self.movies[1].isRented)
        self.assertEqual(len(self.rentals), 4)
        self.assertIsNotNone(self.rentals[1].returnDate)

        self.service.returnMovie([3, 3, 3])
        self.assertFalse(self.movies[3].isRented)
        self.assertEqual(len(self.rentals), 4)
        self.assertIsNotNone(self.rentals[3].returnDate)

        self.assertTrue(self.movies[2].isRented)
        self.assertTrue(self.movies[4].isRented)
Exemplo n.º 10
0
def serve():
    connection_string = 'postgres+psycopg2://{0}:{1}@{2}:{3}/{4}'.format(
        DATABASE_USERNAME, DATABASE_PASSWORD, DATABASE_SERVER, DATABASE_PORT,
        DATABASE_NAME)

    # Initialize Repository
    repository = Repository(connection_string)

    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
                         options=[
                             ('grpc.max_send_message_length', -1),
                             ('grpc.max_receive_message_length', -1),
                         ])

    add_airlines_controller_to_server(server, repository)
    add_planes_controller_to_server(server, repository)
    add_weather_controller_to_server(server, repository)
    add_airports_controller_to_server(server, repository)
    add_flights_controller_to_server(server, repository)

    # engine = repository.get_engine()

    # load_planes(get_all_planes(), engine)
    # load_airlines(get_all_airlines(), engine)
    # load_airports(get_all_airports(), engine)
    # load_weather(get_all_weather(), engine)
    # load_flights(get_all_flights(), engine)

    print("Server running on port 80")
    server.add_insecure_port('[::]:80')
    server.start()

    if len(sys.argv) > 1:
        print("Test Completed Successfully")
    else:
        try:
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            server.stop(0)
Exemplo n.º 11
0
class TestUndo(unittest.TestCase):
    clients = Repository()
    movies = Repository()
    rentals = Repository()
    services = Service(clients, movies, rentals)

    def __reset(self):
        self.clients.reset()
        self.movies.reset()
        self.rentals.reset()

    def testAddClient(self):
        self.__reset()

        self.services.addClient(["Maic"])
        self.services.addClient(["Maichi"])
        self.services.addClient(["Maicuta"])
        self.assertEqual(len(self.clients), 3)

        self.services.undo([])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))

        self.services.redo([])
        self.assertEqual(len(self.clients), 3)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.assertRaises(UndoError, self.services.redo, [])

        self.services.undo([])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))

        self.services.addClient(["Maicq"])
        self.assertRaises(UndoError, self.services.redo, [])

        self.services.undo([])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))

        self.services.undo([])
        self.assertEqual(len(self.clients), 1)
        self.assertEqual(self.clients[1], Client(1, "Maic"))

        self.services.undo([])
        self.assertEqual(len(self.clients), 0)
        self.assertRaises(UndoError, self.services.undo, [])

    def testRemoveClient(self):
        self.__reset()

        self.services.addClient(["Maic"])
        self.services.addClient(["Maichi"])
        self.services.addClient(["Maicuta"])
        self.services.addMovie(["title", "desc", "genre"])
        self.services.rentMovie([2, 1, date(2019, 11, 20), date(2019, 11, 29)])
        self.services.returnMovie([2, 1, 1])

        self.assertEqual(len(self.clients), 3)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)

        self.services.removeClient([2])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 0)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.services.undo([])
        self.assertEqual(len(self.clients), 3)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.services.redo([])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 0)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.assertRaises(UndoError, self.services.redo, [])

        self.services.undo([])
        self.assertEqual(len(self.clients), 3)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.services.removeClient([1])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))
        self.assertRaises(UndoError, self.services.redo, [])

        self.services.undo([])
        self.assertEqual(len(self.clients), 3)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.clients[1], Client(1, "Maic"))
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

        self.services.redo([])
        self.assertEqual(len(self.clients), 2)
        self.assertEqual(len(self.movies), 1)
        self.assertEqual(len(self.rentals), 1)
        self.assertEqual(self.clients[2], Client(2, "Maichi"))
        self.assertEqual(self.clients[3], Client(3, "Maicuta"))

    def testUpdateClient(self):
        self.__reset()

        self.services.addClient(["John"])
        self.assertEqual(self.clients[1].name, "John")

        self.services.updateClient([1, "name", "Vasile"])
        self.assertEqual(self.clients[1].name, "Vasile")

        self.services.updateClient([1, "name", "Vasileul"])
        self.assertEqual(self.clients[1].name, "Vasileul")

        self.services.undo([])
        self.assertEqual(self.clients[1].name, "Vasile")

        self.services.redo([])
        self.assertEqual(self.clients[1].name, "Vasileul")

        self.services.undo([])
        self.services.undo([])
        self.assertEqual(self.clients[1].name, "John")

        self.services.updateClient([1, "name", "Ion"])
        self.assertEqual(self.clients[1].name, "Ion")
        self.assertRaises(UndoError, self.services.redo, [])

    def testAddMovie(self):
        self.__reset()
        self.assertEqual(len([]), 0)
        self.__reset()
        self.assertEqual(len([]), 0)

    def testRemoveMovie(self):
        self.__reset()
        self.assertEqual(len([]), 0)
        self.__reset()
        self.assertEqual(len([]), 0)

    def testUpdateMovie(self):
        self.__reset()
        self.assertEqual(len([]), 0)
        self.__reset()
        self.assertEqual(len([]), 0)

    def testRentMovie(self):
        self.__reset()
        self.assertEqual(len([]), 0)
        self.__reset()
        self.assertEqual(len([]), 0)

    def testReturnMovie(self):
        self.__reset()
        self.assertEqual(len([]), 0)
        self.__reset()
        self.assertEqual(len([]), 0)
Exemplo n.º 12
0
from Repository.repository import Repository
from Controller.controller import Controller
from UI.ui import UI

while True:
    commands = ["1k.txt", "10k.txt", "100k.txt", "example.txt"]
    fileName = input("Insert filename: ")
    if fileName in commands:
        break

repo = Repository(fileName)
repo.readFromFile()
controller = Controller(repo)
new_ui = UI(controller)

new_ui.menu()
new_ui.startapp()