def setUp(self):
self.client = Client()
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpass')
self.user1 = User.objects.create_user('testuser1', '*****@*****.**',
'testpass1')
self.client.login(username='******', password='******')
self.object_client = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_client.save()
self.object_contact = models.Contact(first_name='test1',
last_name='test',
email='*****@*****.**',
phone='123',
client=self.object_client,
owner=self.user)
self.object_contact.save()
self.object_activity = models.Activity(title='test',
text='test',
contact=self.object_contact,
client=self.object_client,
owner=self.user)
self.object_activity.save()
def clients_get_all():
clientsList = models.Client().get_all()
return jsonify(
{'clients':
models.ClientSchema(many=True).dump(clientsList).data}), 200
def populate_vacancy():
for seed in vacancy_csv:
seed_split = seed.split(',')
client = models.Client(seed_split[0], seed_split[1], seed_split[2], int(seed_split[3]))
vacancy = models.Vacancy(client)
vacancies.append(vacancy)
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpass')
self.user1 = User.objects.create_user('testuser1', '*****@*****.**',
'testpass1')
self.client.login(username='******', password='******')
self.object_client = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_client.save()
self.object_client1 = models.Client(name='test123',
loyal=True,
owner=self.user1)
self.object_client1.save()
def test_distinct_activity(self):
self.object_contact = models.Contact(first_name='test1',
last_name='test',
email='*****@*****.**',
phone='123',
owner=self.user)
self.object_client = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_contact.save()
self.object_client.save()
self.object = models.Activity(title='test',
text='test',
contact=self.object_contact,
client=self.object_client,
owner=self.user)
self.object1 = models.Activity(title='test',
text='test',
contact=self.object_contact,
client=self.object_client)
self.object.save()
self.object1.save()
#Недоступность активности без аутентификации
response = self.client.get(reverse('crm:activity', kwargs={'pk': 1}))
self.assertIn("You don't have rights to view this activity",
response.content)
self.assertNotIn('activity', response.context)
response = self.client.get(reverse('crm:activity', kwargs={'pk': 2}))
self.assertIn("You don't have rights to view this activity",
response.content)
self.assertNotIn('activity', response.context)
#Попытка обращения к несуществующей активности без аутентификации
response = self.client.get(reverse('crm:activity', kwargs={'pk': 3}))
self.assertTrue(response.content.startswith('<h1>Not Found</h1>'))
self.client.login(username='******', password='******')
#Успешная попытка получения информации о активносте принадлежащем пользователю
response = self.client.get(reverse('crm:activity', kwargs={'pk': 1}))
self.assertNotIn("You don't have rights to view this activity",
response.content)
self.assertIn('activity', response.context)
#Не успешная попытка получения информации об активности не принадлежащей пользователю
response = self.client.get(reverse('crm:activity', kwargs={'pk': 2}))
self.assertIn("You don't have rights to view this activity",
response.content)
self.assertNotIn('activity', response.context)
#Попытка обращения к несуществующей активности с аутентификацией
response = self.client.get(reverse('crm:activity', kwargs={'pk': 3}))
self.assertTrue(response.content.startswith('<h1>Not Found</h1>'))
def test_delete_client(self):
self.object_contact = models.Contact(first_name='test1',
last_name='test',
email='*****@*****.**',
phone='123',
client=self.object_client,
owner=self.user)
self.object_contact.save()
self.object = models.Activity(title='test',
text='test',
contact=self.object_contact,
client=self.object_client,
owner=self.user)
self.object.save()
#Неуспешное удаление, есть активность
initial_data = {'action': 'Delete'}
self.assertRaises(ProtectedError,
self.client.post,
path=reverse('crm:client', kwargs={'pk': 1}),
data=initial_data)
#Создаем еще клиента
self.object_client1 = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_client1.save()
self.client.login(username='******',
password='******') #Перелогиниваемся
#Пробуем удалить - неуспешно, не клиент текущего пользователя
data_correct_input = {'action': 'Delete'}
response = self.client.post(reverse('crm:client', kwargs={'pk': 2}),
data_correct_input)
self.assertRedirects(response, reverse('crm:client', kwargs={'pk': 2}))
self.assertEqual(response.status_code, 302)
self.assertTrue(models.Client.objects.get(pk=2))
self.client.login(username='******',
password='******') #Перелогиниваемся
#Успешное удаление
initial_data = {'action': 'Delete'}
response = self.client.post(reverse('crm:client', kwargs={'pk': 2}),
initial_data)
self.assertEqual(
self.client.session['deleted_data'],
'Name: test1, Id: 2') #Проверяем, что сохранили информацию
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('crm:main'))
self.assertEqual(models.Client.objects.count(), 1)
def test_distinct_client(self):
self.object = models.Client(name='test1', loyal=True, owner=self.user)
self.object1 = models.Client(name='test2',
loyal=True,
owner=self.user1)
self.object.save()
self.object1.save()
#Недоступность клиентов без аутентификации
response = self.client.get(reverse('crm:client', kwargs={'pk': 1}))
self.assertIn("You don't have rights to view this client",
response.content)
self.assertNotIn('client', response.context)
response = self.client.get(reverse('crm:client', kwargs={'pk': 2}))
self.assertIn("You don't have rights to view this client",
response.content)
self.assertNotIn('client', response.context)
#Попытка обращения к несуществующему клиенту без аутентификации
response = self.client.get(reverse('crm:client', kwargs={'pk': 3}))
self.assertTrue(response.content.startswith('<h1>Not Found</h1>'))
self.client.login(username='******', password='******')
#Успешная попытка получения информации о клиенте принадлежащем пользователю
response = self.client.get(reverse('crm:client', kwargs={'pk': 1}))
self.assertNotIn("You don't have rights to view this client",
response.content)
self.assertIn('client', response.context)
#Не успешная попытка получения информации о клиента не принадлежащем пользователю
response = self.client.get(reverse('crm:client', kwargs={'pk': 2}))
self.assertIn("You don't have rights to view this client",
response.content)
self.assertNotIn('client', response.context)
#Попытка обращения к несуществующему клиенту с аутентификацией
response = self.client.get(reverse('crm:client', kwargs={'pk': 3}))
self.assertTrue(response.content.startswith('<h1>Not Found</h1>'))
def testEntityCD(self):
logging.debug('Testing entity create & delete...')
sponsor = models.Sponsor()
sponsor.name = 'Test Sponsor'
sponsor.url = 'http://www.redcross.com'
sponsor.address = '123 blaj blah, blah WA,USA'
sponsor.phone = '(555)555-555'
sponsor.put()
assert sponsor.key()
test_client = models.Client()
test_client.set_defaults()
test_client.displayName = "Bob"
test_client.fullName = "Bob the builder"
test_client.story = lorem_ipsum
test_client.sponsor = sponsor
test_client.imageURL = "http://www.test.org/img.png"
test_client.put()
assert test_client.key()
test_donor = models.Donor()
test_donor.address = "123 123 123"
test_donor.name = "Donor"
test_donor.phone = "(206)555-5555"
test_donor.put()
assert test_donor.key()
test_user = models.User()
test_user.user = users.get_current_user()
test_user.isAdmin = True
test_user.sponsor = sponsor
test_user.put()
assert test_user.key()
tx = models.Transaction()
fromAccount = 'stripe'
toAccount = '%s/%s' % (sponsor.key(), test_client.key())
amount = 1.00
type = 'CREDIT'
note = 'A donation from Bob'
confirm = False
tx.put()
# clean up
tx.delete()
test_user.delete()
test_client.delete()
sponsor.delete()
test_donor.delete()
self.response.out.write("<html><body><p>Test Passed!</p></body></html>")
def setUp(self):
self.object_client = models.Client(name='test', loyal=False)
self.object_client.save()
self.object_contact = models.Contact(first_name='test1',
last_name='test',
email='*****@*****.**',
phone='123',
client=self.object_client)
self.object_contact.save()
self.object = models.Activity(title='test',
text='test',
contact=self.object_contact,
client=self.object_client)
self.object.save()
def clients_create():
data = request.get_json()
try:
client = models.Client(**data)
except:
return jsonify({'message': 'Invalid parameter for client'}), 403
if models.Client.get_one(id=client.id) != None:
return jsonify({'message': 'Resource already exists'}), 409
if not client.add():
return jsonify({'message': 'Something is going wrong'}), 500
return jsonify({'client': models.ClientSchema().dump(client).data}), 201
def test_change_client(self):
self.object_client1 = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_client1.save()
#Попытка изменения имени клиента на уже существующее
initial_data = {'name': 'test1', 'loyal': True}
response = self.client.post(reverse('crm:client', kwargs={'pk': 1}),
initial_data)
self.assertFalse(response.context['form'].is_valid())
self.assertFormError(response, 'form', 'name',
"Client with this Name already exists.")
#Попытка передачи пустого имени
initial_data = {'loyal': True}
response = self.client.post(reverse('crm:client', kwargs={'pk': 1}),
initial_data)
self.assertFalse(response.context['form'].is_valid())
self.assertFormError(response, 'form', 'name',
"This field is required.")
#Попытка передачи пустой формы
initial_data = {}
response = self.client.post(reverse('crm:client', kwargs={'pk': 1}),
initial_data)
self.assertFalse(response.context['form'].is_valid())
self.assertFormError(response, 'form', 'name',
"This field is required.")
#Попытка изменения не своего клиента
self.client.login(username='******', password='******')
initial_data = {'name': 'test2'}
response = self.client.post(reverse('crm:client', kwargs={'pk': 1}),
initial_data)
self.assertRedirects(response, reverse('crm:client', kwargs={'pk': 1}))
self.assertEqual(response.status_code, 302)
self.assertEqual(models.Client.objects.get(pk=1).name, 'test')
#Успешная попытка изменения
self.client.login(username='******', password='******')
initial_data = {'name': 'test2'}
response = self.client.post(reverse('crm:client', kwargs={'pk': 1}),
initial_data)
self.assertRedirects(response, reverse('crm:client', kwargs={'pk': 1}))
self.assertEqual(response.status_code, 302)
self.assertEqual(models.Client.objects.get(pk=1).name, 'test2')
def start_connection(self, host, port):
# Connection to server
addr = (host, port)
print('starting connection to', addr)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.connect_ex(addr)
# Create Client datatype
events = selectors.EVENT_READ | selectors.EVENT_WRITE
myHost, myPort = sock.getsockname()
data = models.Client(sock, myPort)
# Add socket to selectors
self.sel.register(sock, events, data=data)
return data
def store():
try:
name = request.json['name']
username = request.json['username']
email = request.json['email']
password = request.json['password']
new_client = models.Client(name, username, email, password)
db.session.add(new_client)
db.session.commit()
return jsonify({'client_id': new_client.id})
except IntegrityError as e:
db.session.rollback()
return jsonify({'error': e.orig.args[0]}), 400
except KeyError as e:
db.session.rollback()
return jsonify({'error': 'Missing ' + ','.join(e.args)}), 400
def buildKodiac(self):
kodiac = models.Client()
kodiac.set_defaults()
kodiac.shortCode = 'kodiak'
kodiac.name = "Kodiak"
kodiac.fullName = "Chris"
kodiac.imageURL = "/images/clients/Kodiak.png"
kodiac.sponsor = self.sponsors[0]
kodiac.story = \
"""<p>Meet Chris. His friends call him \"Kodiak\".</p>
<p>He has a bear of a personality and always hugs instead of shaking hands.
Moved to Seattle this past fall, but have been unable to find a job or steady housing.
He is currently living in a men's shelter that doesn't have a kitchen or any refrigeration.
<p>The food stamps he gets can only be used for dry foods - everything which he has to carry in
his backpack. He wants a hot meal and a new winter coat.</p><p> You can help.</p>
"""
kodiac.put()
self.clients.append(kodiac)
def main() -> None:
"""
Main client function, it will read command-line, create a models.Client instance
and call its run() method.
:return: None
"""
address, port = read_options()
context = ssl.create_default_context()
context.check_hostname = False
context.load_verify_locations(os.getenv("PATH_TO_CERT"))
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((address, port))
client_socket = context.wrap_socket(client_socket)
print(models.Constants.connected_message(address, port))
client = models.Client(address, client_socket, context)
client.run()
def test_clients(self):
self.object = models.Client(name='test1', loyal=True, owner=self.user)
self.object.save()
#Проверка доступности клиента без аутентификации
response = self.client.get(reverse('crm:clients'))
self.assertIn('No clients are available.', response.content)
self.assertNotIn('test1', response.content)
self.assertFalse(response.context['clients_list'])
#Недоступность чужих клиентов
self.client.login(username='******', password='******')
response = self.client.get(reverse('crm:clients'))
self.assertIn('No clients are available.', response.content)
self.assertFalse(response.context['clients_list'])
#Доступность своего клиента
self.client.login(username='******', password='******')
response = self.client.get(reverse('crm:clients'))
self.assertNotIn('No clients are available.', response.content)
self.assertIn('test1', response.content)
self.assertTrue(response.context['clients_list'])
def contacts_create(id):
data = request.get_json()
try:
contact = models.Contact(**data)
except:
return jsonify({'message': 'Invalid parameters for contact'}), 403
if models.Contact.get_one(id=contact.id) != None:
return jsonify({'message': 'Resource already exists'}), 409
contact.client = models.Client().get_one(id=id)
if contact.client == None:
return jsonify({'message': 'resource not found'}), 404
if not contact.add():
return jsonify({'message': 'Something is going wrong'}), 500
return jsonify({'contact': models.ContactSchema().dump(contact).data}), 201
def get(self):
sponsor = models.Sponsor()
sponsor.name = random_sentence(3).title()
sponsor.url = 'http://www.redcross.com/'
sponsor.address = '123 Streeet Ave. S, Blah WA,USA'
sponsor.phone = '(555)555-555'
sponsor.put()
self.response.out.write("<p>Created Sponsor:[%s] </p>" %
(sponsor.key().id_or_name()))
for i in range(0, 5):
test_client = models.Client()
test_client.set_defaults()
test_client.displayName = "Bob"
test_client.fullName = "Bob " + random_sentence(1).title()
test_client.story = '<p>' + random_sentence(100) + '</p>'
test_client.sponsor = sponsor
test_client.imageURL = "http://www.test.org/img%i.png" % i
test_client.put()
self.response.out.write("<p>Created Client:[%s]</p>" %
test_client.key().id_or_name())
def test_activities(self):
self.object_contact = models.Contact(first_name='test1',
last_name='test',
email='*****@*****.**',
phone='123',
owner=self.user)
self.object_client = models.Client(name='test1',
loyal=True,
owner=self.user)
self.object_contact.save()
self.object_client.save()
self.object = models.Activity(title='test1',
text='test',
contact=self.object_contact,
client=self.object_client,
owner=self.user)
self.object.save()
#Проверка доступности активности без аутентификации
response = self.client.get(reverse('crm:activities'))
self.assertIn('No activities are available', response.content)
self.assertNotIn('test1', response.content)
self.assertFalse(response.context['activities_list'])
#Недоступность чужих активностей
self.client.login(username='******', password='******')
response = self.client.get(reverse('crm:activities'))
self.assertIn('No activities are available', response.content)
self.assertFalse(response.context['activities_list'])
#Доступность своей активности
self.client.login(username='******', password='******')
response = self.client.get(reverse('crm:activities'))
self.assertNotIn('No activities are available', response.content)
self.assertIn('test1', response.content)
self.assertTrue(response.context['activities_list'])
def add_clients():
name = input("Insira o nome: ")
cpf = input("Insira o CPF: ")
car_board = input("Insira a placa do carro: ")
while True:
try:
status = int(input("Insira o status: "))
if status != models.Status.ACTIVE and status != models.Status.INACTIVE:
raise Exception(
'Insira um status valido (1 - ATIVO ou 2 - INATIVO)')
except Exception as e:
print(e)
else:
break
client = models.Client(name, cpf, car_board, status)
try:
create_client(client)
except Exception as e:
print(e)
def on_post(self, req, resp):
data = req.media
db_session = req.context['db_session']
client = models.Client(**data)
db_session.add(client)
db_session.flush()
for cur_name in {'USD', 'RUB'}:
cur = db_session.query(
models.Currency).filter_by(name=cur_name).one()
acc = models.TransactionAccount(client_id=client.id,
currency_id=cur.id,
balance=0)
client.transaction_accounts.append(acc)
db_session.commit()
resp_payload = {
'created': {
'client_account':
str(client),
'transaction_accounts':
[str(acc) for acc in client.transaction_accounts]
}
}
resp.body = json.dumps(resp_payload)
def populate_clients():
for seed in clients_csv:
seed_split = seed.split(',')
client = models.Client(seed_split[0], seed_split[1], seed_split[2], int(seed_split[3]))
clients.append(client)
def test_change_activity(self):
self.object_client1 = models.Client(name='test2',
loyal=True,
owner=self.user)
self.object_client1.save()
self.object_contact1 = models.Contact(first_name='test2',
last_name='test',
email='*****@*****.**',
phone='123',
client=self.object_client1,
owner=self.user)
self.object_contact1.save()
#Пробуем изменить активность выбрав клиента, который не связан с контактом
data_client_input = {
'title': 'test',
'text': 'test',
'client': 2,
'contact': 1
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 1}),
data_client_input)
self.failIf(response.context['form'].is_valid())
self.assertIn('Chosen contact doesn't belong to chosen client',
response.content)
#Аналогично пытаемся отправить форму с контактом не связанным с клиентом
data_contact_input = {
'title': 'test',
'text': 'test',
'client': 1,
'contact': 2
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 1}),
data_contact_input)
self.failIf(response.context['form'].is_valid())
self.assertIn('Chosen contact doesn't belong to chosen client',
response.content)
#Передаем связанных клиента/контакта, успешно меняем запись
data_correct_input = {
'title': 'test',
'text': 'test',
'client': 2,
'contact': 2
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 1}),
data_correct_input)
self.assertRedirects(response, reverse('crm:activity',
kwargs={'pk': 1}))
self.assertEqual(response.status_code, 302)
#Проверяем, что новые значения сохранились в базе данных
activity = models.Activity.objects.get(pk=1)
self.assertTrue(activity.client.id == activity.contact.id == 2)
#Проверяем невозможность изменения отправленной активности
content = {'action': 'Send'}
self.client.post(reverse('crm:activity', kwargs={'pk': 1}), content)
activity = models.Activity.objects.get(pk=1)
self.assertIsNotNone(
activity.send_date) #Проверяем, что дата отправки проставилась
data_correct_input = {
'title': 'test',
'text': 'test',
'client': 1,
'contact': 1
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 1}),
data_correct_input)
self.failIf(response.context['form'].is_valid())
self.assertFormError(response, 'form', None,
"You can't change activity which was sent")
#Создаем еще одну активность
self.object2 = models.Activity(title='test1',
text='test1',
contact=self.object_contact,
client=self.object_client,
owner=self.user)
self.object2.save()
self.client.login(username='******',
password='******') #Перелогиниваемся
#Пробуем изменить - неуспешно, так как пользователь - не owner объекта
data_correct_input = {
'title': 'test1123',
'text': 'test',
'client': 1,
'contact': 1
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 2}),
data_correct_input)
self.assertRedirects(response, reverse('crm:activity',
kwargs={'pk': 2}))
self.assertEqual(response.status_code, 302)
self.assertEqual(models.Activity.objects.get(pk=2).title, 'test1')
#Пробуем удалить - неуспешно
data_correct_input = {'action': 'Delete'}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 2}),
data_correct_input)
self.assertRedirects(response, reverse('crm:activity',
kwargs={'pk': 2}))
self.assertEqual(response.status_code, 302)
self.assertTrue(models.Activity.objects.get(pk=2))
self.client.login(username='******',
password='******') #Перелогиниваемся
#Пробуем изменить - успешно
data_correct_input = {
'title': 'test1',
'text': 'test',
'client': 2,
'contact': 2
}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 2}),
data_correct_input)
self.assertRedirects(response, reverse('crm:activity',
kwargs={'pk': 2}))
self.assertEqual(response.status_code, 302)
#Пробуем удалить
data_correct_input = {'action': 'Delete'}
response = self.client.post(reverse('crm:activity', kwargs={'pk': 2}),
data_correct_input)
self.assertTrue(self.client.session['deleted_data']
) #Проверяем, что сохранили информацию
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('crm:main'))
self.assertEqual(models.Activity.objects.count(), 1)
def test_creation_activity(self):
error = "Select a valid choice. That choice is not one of the available choices."
#Попытка создания с несуществующим клиентом
initial_data = {
'title': 'test',
'text': 'test',
'client': 5,
'contact': 1
}
response = self.client.post(reverse('crm:new_activity'), initial_data)
self.assertFalse(response.context['form'].is_valid())
self.assertFormError(response, 'form', 'client', error)
#Попытка создания с несуществующим контактом
initial_data = {
'title': 'test',
'text': 'test',
'client': 1,
'contact': 5
}
response = self.client.post(reverse('crm:new_activity'), initial_data)
self.assertFalse(response.context['form'].is_valid())
self.assertFormError(response, 'form', 'contact', error)
#Успешная попытка создания
initial_data = {
'title': 'test',
'text': 'test',
'client': 1,
'contact': 1
}
response = self.client.post(reverse('crm:new_activity'), initial_data)
self.assertRedirects(response, reverse('crm:activity',
kwargs={'pk': 2}))
self.assertEqual(response.status_code, 302)
#Попытка создания с чужим клиентом/контактом
self.object_client1 = models.Client(name='test2',
loyal=True,
owner=self.user1)
self.object_client1.save()
self.object_contact1 = models.Contact(first_name='test2',
last_name='test',
email='*****@*****.**',
phone='123',
client=self.object_client1,
owner=self.user1)
self.object_contact1.save()
initial_data = {
'title': 'test',
'text': 'test',
'client': 2,
'contact': 2
}
response = self.client.post(reverse('crm:new_activity'), initial_data)
self.assertFormError(response, 'form', 'client', error)
def setUp(self):
self.object = models.Client(name='test', loyal=False)
self.object.save()
def test_unique_name(self):
#Попытка сохранения клиента с существующим именем
self.object1 = models.Client(name='test', loyal=True)
self.assertRaises(IntegrityError, self.object1.save)
def test_diff_name(self):
#Сохранение клиента с уникальным именем
self.object1 = models.Client(name='test1', loyal=True)
self.object1.save()
self.assertEqual(models.Client.objects.count(), 2)
import models
from models import settings
import psutil
import time
import numpy as np
if __name__ == "__main__":
if input("The current data will be destroyed, is this ok?") == "y":
cpus = []
t = 0
dc = models.DC(cap=settings.MAX_SERVER_LOAD)
clients = list()
clients.append(models.Client(2, settings.CLIENT1_BW, dc))
clients.append(models.Client(3, settings.CLIENT2_BW, dc))
clients.append(models.Client(4, settings.CLIENT3_BW, dc))
rp = models.RewardProvider('192.168.0.22', clients, dc)
try:
while 1:
print(
"T =", t,
" ------------------------------------------------------------------"
)
cpus.append(psutil.cpu_percent())
print("CPU=", np.mean(cpus))
time.sleep(settings.STEP)
rp.step()
t += 1
print(cpus)
except:
print(cpus)
