def SendCustomerAddressUpdatedEmail(self,CustomerId,NewAddress,MessageId):
print('You changed your address successfully')
Repository().UpdateCustomerAddress(CustomerId,NewAddress,MessageId)
customer = Repository().GetCustomer(CustomerId)
for key,value in customer.items():
print(f'{key} : {value}')
Repository().UpdateCustomerAddress(CustomerId,NewAddress,MessageId)
def testAddSentence_ValidSentence_SentenceAdded(self):
sentences_repository = Repository('sentences.txt')
game_service = GameService(sentences_repository)
game_service.add_sentence(["batman is on duty"])
self.assertEqual(["batman is on duty"]
in sentences_repository.get_sentences(), True)
def setUp(self):
student_repo = Repository()
assignment_repo = Repository()
grade_repo = Repository()
student_validator = Student_Validator()
assignment_validator = Assignment_Validator()
grade_validator = Grade_Validator()
self._undo_service = UndoService()
student_service = studentService(student_repo, grade_repo, student_validator, self._undo_service )
assignment_service = assignmentService(assignment_repo, grade_repo, assignment_validator, self._undo_service)
grade_service = gradeService(student_repo, assignment_repo, grade_repo, student_validator, assignment_validator,grade_validator, self._undo_service)
student_validator = Student_Validator()
assignment_validator = Assignment_Validator()
grade_validator = Grade_Validator()
self._student_list = student_service
self._assignment_list = assignment_service
self._grade_list = grade_service
self.list_s.add_student('124', 'Mark Park', '912')
self.list_s.add_student('125', 'Mark Park', '912')
self.list_s.add_student('126', 'Mark Park', '912')
self.list_s.add_student('127', 'Mark Park', '913')
self.list_s.add_student('128', 'Mark Park', '914')
self.assing_list.add_assignment('124', 'Homework due Tomorrow', '2021-12-22')
self.assing_list.add_assignment('125', 'Homework due Tomorrow', '2021-12-22')
self.assing_list.add_assignment('126', 'Homework due Tomorrow', '2021-12-22')
self.assing_list.list_of_assignments.add_object(Assignment('127', 'Homework due Tomorrow', '2020-10-22'))
def setUp(self):
assignment_repo = Repository()
grade_repo = Repository()
assignment_validator = Assignment_Validator()
self._undo_service = UndoService()
self._assignment_list = assignmentService(assignment_repo, grade_repo, assignment_validator,self._undo_service)
self._assignment_repo = Repository()
def setUp(self):
TestCase.setUp(self)
self.repository = Repository()
holy1 = Holiday("1", "London", "seaside", 260)
holy2 = Holiday("2", "Constanta", "seaside", 160)
self.repository.addItem(holy1)
self.repository.addItem(holy2)
def setUp(self):
student_repo = Repository()
grade_repo = Repository()
student_validator = Student_Validator()
undo_service = UndoService()
student_service = studentService(student_repo, grade_repo, student_validator,undo_service)
self._student_list = student_service
self._student_list_repo = student_repo
def __init__(self, filename, readEntity, writeEntity):
'''
Constructor
'''
Repository.__init__(self)
self.__filename = filename
self.__readEntity = readEntity
self.__writeEntity = writeEntity
self.__readFromFile()
def SendOrderApprovedEmail(self,OrderId,CustomerId,ProductName,ProductValue,MessageId):
customer = Repository().GetCustomer(CustomerId)
print(f'Your order got approved')
for key,value in customer.items():
if key != 'Email':
print(f'{key} : {value}')
print(f'OrderId : {OrderId}')
print(f'ProductName : {ProductName}')
print(f'ProductValue : {ProductValue}')
Repository().SaveMessageId(MessageId)
class TestRepository(unittest.TestCase):
def setUp(self):
TestCase.setUp(self)
self.repository = Repository()
holy1 = Holiday("1", "London", "seaside", 260)
holy2 = Holiday("2", "Constanta", "seaside", 160)
self.repository.addItem(holy1)
self.repository.addItem(holy2)
def test_add(self):
holy3 = Holiday("3", "Chisinau", "city-break", 260)
self.repository.addItem(holy3)
self.assertEqual(len(self.repository.getAll()), 3)
class TestRepo(unittest.TestCase):
def setUp(self):
self.__repo = Repository()
self.__entity = student(1, "Bogdan")
def tearDown(self):
del self.__repo
del self.__entity
def testRepo(self):
assert len(self.__repo.getAll()) == 0
self.__repo.store(self.__entity)
assert self.__repo.findById(1).nume == "Bogdan"
def __loadFromFile(self):
try:
f = open(self.__fName, "r")
line = f.readline().strip()
while line != "":
attrs = line.split(";")
student = Student(attrs[0], attrs[1], attrs[2])
Repository.add(self, student)
line = f.readline().strip()
except IOError as e:
raise e
finally:
f.close()
def TestAdd(self):
'''
Testeaza functia de adaugare unui element
'''
repo = Repository()
repo.add(1)
assert repo.getAll() == [1]
repo.add(2)
assert repo.getAll() == [1, 2]
try:
repo.add(1)
assert False
except RepositoryExceptions:
assert True
class Controller:
# we hold a storage reference
# and we also make a list with the Bet_Tickets
def __init__(self):
self.__repo = Repository()
self.__resulting_tickets = []
self.init_Strategies()
def init_Strategies(self):
# this function will add into the resulting_tickets the tickets
# which are obtained following the strategies
self.trebleStrategy()
def get_storage(self):
return self.__repo.getStorage()
def preety_print(self):
self.__repo.print_all_storage()
def trebleStrategy(self):
# we make the list for the trebleStrategy 1/4 1/5 1/6
one_to_six = []
one_to_five = []
one_to_four = []
for item in self.get_storage():
# print(item.get_odds())
for key, value in item.get_odds().items():
selected_match = Selected_Match(item.toString(), key, value)
if Decimal(float(value)) == 1.17:
one_to_six.append(selected_match)
elif Decimal(float(value)) == 1.20:
one_to_five.append(selected_match)
elif Decimal(float(value)) == 1.25:
one_to_four.append(selected_match)
for index in range(
0, min(len(one_to_six), len(one_to_five), len(one_to_four))):
current_ticket = Bet_Ticket()
current_ticket.addMatch(one_to_four[index])
current_ticket.addMatch(one_to_five[index])
current_ticket.addMatch(one_to_six[index])
self.__resulting_tickets.append(current_ticket)
def get_Betting_Tickets(self):
return self.__resulting_tickets
def TestGetTopMedii (self):
'''
Testeaza functia de obtinere a mediilor in ordine descrescatoare
'''
repo = RepositoryNota ()
NoteServ = NotaService (repo)
StudServ = StudentService(Repository())
StudServ.adaugaStudent(Student(1,'asd'))
StudServ.adaugaStudent(Student(2,'asd'))
nota1 = Nota (1,2,9)
nota2 = Nota (1,5,10)
nota3 = Nota (1,2,7)
nota4 = Nota (1,5,7)
nota5 = Nota (1,2,8)
nota6 = Nota (2,2,9)
nota7 = Nota (2,2,8)
NoteServ.AdaugaNota(nota1)
NoteServ.AdaugaNota(nota2)
NoteServ.AdaugaNota(nota3)
NoteServ.AdaugaNota(nota4)
NoteServ.AdaugaNota(nota5)
NoteServ.AdaugaNota(nota6)
NoteServ.AdaugaNota(nota7)
listNote = NoteServ.GetNote()
listStud = StudServ.getStudenti()
assert NoteServ.GetTopMedii(listNote, listStud) == [8.5, 8.2]
def init_empty(self):
disciplines_repository = Repository()
students_repository = Repository()
grades_repository = Repository()
discipline_validator = DisciplineValidator()
student_validator = StudentValidator()
grade_validator = GradeValidator()
self.__discipline_service = DisciplineService(disciplines_repository,
discipline_validator)
self.__student_service = StudentService(students_repository,
student_validator)
self.__grade_service = GradeService(disciplines_repository,
students_repository,
grades_repository, grade_validator)
def setUp(self):
student_repo = Repository()
assignment_repo = Repository()
grade_repo = Repository()
student_validator = Student_Validator()
assignment_validator = Assignment_Validator()
grade_validator = Grade_Validator()
undo_service = UndoService()
self._undo_service = undo_service
student_service = studentService(student_repo, grade_repo, student_validator, self._undo_service )
assignment_service = assignmentService(assignment_repo, grade_repo, assignment_validator, self._undo_service)
grade_service = gradeService(student_repo, assignment_repo, grade_repo, student_validator, assignment_validator,grade_validator, self._undo_service)
self._grades_list = grade_service
self._assignments = assignment_service
self._student_list = student_service
def testComputerTurn_AddsALetterToHangWord(self):
sentences_repository = Repository('sentences.txt')
game_service = GameService(sentences_repository)
game_service.choose_sentence()
game_service._computer_turn()
self.assertEqual(game_service.get_hangman_game_word(), "h")
def TestInit(self):
'''
Testeaza functia de initializare a unei DisciplinaService
'''
repo = Repository()
DiscCtrl = DisciplinaService (repo)
assert DiscCtrl.getDiscipline() == []
class TestController(unittest.TestCase):
def setUp(self):
TestCase.setUp(self)
self.repository = Repository()
self.controller = Controller(self.repository)
holy1 = Holiday("1", "London", "seaside", 260)
holy2 = Holiday("2", "Constanta", "seaside", 160)
holy3 = Holiday("3", "Chisinau", "city-break", 260)
self.repository.addItem(holy1)
self.repository.addItem(holy2)
self.repository.addItem(holy3)
def test_type(self):
self.assertEqual(len(self.controller.filterByType("seaside")), 2)
def test_resort(self):
self.controller.filterByResort("London")
self.assertEqual(len(self.controller.filterByResort("London")), 1)
def __storeToFile(self):
f = open(self.__fName, "w")
sts = Repository.getAll(self)
for st in sts:
strf = str(st.get_id()) + ";" + st.get_name() + ";" + str(
st.get_group())
strf = strf + "\n"
f.write(strf)
f.close()
def biconnectedComponent(self, listOfVertices):
newGraph = Graph()
for counter in listOfVertices:#copies dictionary of edges
newGraph._dict[counter] = self._repo._graph._dict[counter]
newGraph._nrVertices = len(listOfVertices)
checkForBiconnected = True
for counter in listOfVertices:
newGraph2 = Graph()
newGraph2._dict = deepcopy(newGraph._dict)
newGraph2._nrVertices = deepcopy(newGraph._nrVertices)
newRepo = Repository(newGraph2)
newRepo.removeVertex(counter)
if (len(newRepo.connectedComponents()) != 1):
checkForBiconnected = False
if checkForBiconnected == True:
return True
else:
return False
def __init__(self):
'''
This method initializes the class with some data.
Input:
- none
Output:
- none
'''
self.__repository = Repository()
self.__elevator_1 = Elevator()
self.__elevator_2 = Elevator(6)
self.__floor = Floor()
self.__listOfFloors = []
for index in range(0, 7):
self.__listOfFloors.append(self.__floor)
def setUp(self):
TestCase.setUp(self)
self.repository = Repository()
self.controller = Controller(self.repository)
holy1 = Holiday("1", "London", "seaside", 260)
holy2 = Holiday("2", "Constanta", "seaside", 160)
holy3 = Holiday("3", "Chisinau", "city-break", 260)
self.repository.addItem(holy1)
self.repository.addItem(holy2)
self.repository.addItem(holy3)
def test_remove_assignment_service(self):
self.assing_list.add_assignment('124', 'Homework due Tomorrow',
'2021-12-22')
self.assing_list.add_assignment('125', 'Homework due Tomorrow',
'2021-12-22')
self.assing_list.add_assignment('126', 'Homework due Tomorrow',
'2021-12-22')
self.assing_list.add_assignment('127', 'Homework due Tomorrow',
'2021-12-22')
student_repo = Repository()
assignment_repo = Repository()
grade_repo = Repository()
student_validator = Student_Validator()
assignment_validator = Assignment_Validator()
grade_validator = Grade_Validator()
g_list = gradeService(student_repo, assignment_repo, grade_repo,
student_validator, assignment_validator,
grade_validator, self._undo_service)
self.assing_list.remove_assignment('124')
self.assertEqual(len(self.assing_list.list_of_assignments), 3)
try:
self.assing_list.remove_assignment('124')
self.assertFalse('Not good')
except AssignmentException:
self.assertTrue('OK')
try:
self.assing_list.remove_assignment('124a')
self.assertFalse('Not good')
except AssignmentException:
self.assertTrue('OK')
try:
self.assing_list.remove_assignment('125')
self.assertTrue('OK')
except AssignmentException:
self.assertFalse('Not good')
self.assertEqual(len(self.assing_list.list_of_assignments), 2)
def TestDeterminareDisciplineOrdonateAlfabetic (self):
'''
Testeaza functia de determinare a disciplinelor ordonate alfabetic
'''
repo = Repository()
DiscCtrl = DisciplinaService (repo)
DiscCtrl.adaugaDisciplina(Disciplina (1,'Mate','Nistor'))
DiscCtrl.adaugaDisciplina(Disciplina (2,'Istorie','Lostun'))
DiscCtrl.adaugaDisciplina(Disciplina (3,'Analiza','Berinde Stefan'))
DiscCtrl.adaugaDisciplina(Disciplina (4,'Fizica','Bejan'))
disciplineOrdonate = DiscCtrl.getDisciplineSortate()
assert disciplineOrdonate == [Disciplina (3,'Analiza','Berinde Stefan'), Disciplina(4,'Fizica','Bejan'), Disciplina (2,'Istorie','Lostun'), Disciplina (1, 'Mate','Nistor')]
def __init__(self):
self.__id = 1
self.__name = "George"
self.__group = 100
self.__student = Student(self.__id, self.__name, self.__group)
self.__validator = studentValidator()
self.__badId = -902
self.__badName = ""
self.__badGroup = 1000
self.__badStudent = Student(self.__badId, self.__badName,
self.__badGroup)
self.__repository = Repository()
self.__gradeValidator = gradeValidator()
self.__gradeRepo = Repository()
self.__gradeController = gradeController(self.__gradeRepo,
self.__repository,
self.__gradeValidator)
self.__controller = studentController(self.__repository,
self.__validator)
def TestRemoveDisciplina (self):
'''
Testeaza functia de stergere a unei discipline
'''
repo = Repository ()
DiscCtrl = DisciplinaService (repo)
DiscCtrl.adaugaDisciplina(Disciplina (1,'Mate','Lostun'))
DiscCtrl.removeDisciplina(Disciplina (1,'Mate','Lostun'))
try:
DiscCtrl.removeDisciplina( Disciplina (2,'Istorie','Pasvante'))
assert False
except RepositoryExceptions:
assert True
def test_remove_student_service(self):
stud = Student('123', 'Mark Park', '912')
student_repo = Repository()
assignment_repo = Repository()
grade_repo = Repository()
student_validator = Student_Validator()
assignment_validator = Assignment_Validator()
grade_validator = Grade_Validator()
undo_service = UndoService()
g_list = gradeService(student_repo, assignment_repo, grade_repo,
student_validator, assignment_validator,
grade_validator, undo_service)
self.list_s.add_student('234', 'Mark Park', '912')
self.list_s.add_student('235', 'Mark Park', '912')
self.list_s.add_student('236', 'Mark Park', '912')
self.list_s.remove_student('234')
self.assertEqual(len(self.list_s.student_list_service), 2)
try:
self.list_s.remove_student('234')
self.assertFalse('Not good')
except studentException:
self.assertTrue('OK')
try:
self.list_s.remove_student('za2')
self.assertFalse('Not good')
except studentException:
self.assertTrue('OK')
try:
self.list_s.remove_student('392')
self.assertFalse('Not good')
except studentException:
self.assertTrue('OK')
self.assertEqual(len(self.list_s.student_list_service), 2)
def TestFind(self):
'''
Testeaza functia de cautare a unui element din Repository
'''
repo = Repository()
try:
repo.find(1)
assert False
except RepositoryExceptions:
assert True
repo.add(1)
assert repo.find(1) == 1
def test__add__dates_wrong(self):
repo = Repository()
rooms = FileRepository("../Data/rooms.txt", Room)
service = ReservationService(repo, rooms, Validator)
name = "Sera"
type = 1
num_guests = 1
arrival_day = 2
arrival_month = 1
departure_day = 1
departure_month = 1
self.assertRaises(ServiceException, service.add, name, type,
num_guests, arrival_day, arrival_month,
departure_day, departure_month)
def TestUpdateDisciplina (self):
'''
Testeaza functia de actualizare a unui discipline
'''
repo = Repository ()
DiscCtrl = DisciplinaService (repo)
discVeche = Disciplina (1,'Mate','Nistor')
DiscCtrl.adaugaDisciplina(discVeche)
discNoua = Disciplina (1, 'Istorie', 'Lostun')
DiscCtrl.updateDisciplina(discVeche, discNoua)
assert DiscCtrl.getDiscipline() == [discNoua]
try:
DiscCtrl.updateDisciplina(Disciplina(3,'Istorie','Marin'), Disciplina (3,'Mate','Nistor'))
assert False
except RepositoryExceptions:
assert True
def TestAdaugaDisciplina (self):
'''
Testeaza functia de adaugare a unei discipline
'''
repo = Repository()
DiscCtrl = DisciplinaService (repo)
disc = Disciplina (1,'Mate','Nistor')
DiscCtrl.adaugaDisciplina(disc)
assert DiscCtrl.getDiscipline() == [disc]
disc2 = Disciplina (2, 'Istorie', 'Lostun')
DiscCtrl.adaugaDisciplina(disc2)
assert DiscCtrl.getDiscipline () == [disc, disc2]
disc3 = Disciplina (1, 'Fizica', 'Bejan')
try:
DiscCtrl.adaugaDisciplina(disc3)
assert False
except RepositoryExceptions:
assert True
'''
Created on Oct 27, 2013
@author: Zehel
'''
from Repository.Repository import Repository
if __name__ == '__main__':
rep = Repository("../sample.cpp")
for token in rep.tokenize():
print token