def test_place_in_multiple_servers(self):
"""
Each client placed in a server, with multiplicative_factor one.
For each server, the used capacity equals the sum of its clients' demands.
"""
number_servers = 30
number_clients = 1000
server_manager = ServerManager()
client_manager = ClientManager()
servers = [
server_manager.create_server() for i in range(number_servers)
]
clients = [
client_manager.create_client(random.randint(10, 30))
for i in range(number_clients)
]
placement_manager = PlacementManager(servers)
server = 0
for client in clients:
placement_manager.place_client(client, servers[server])
server = (server + 1) % number_servers
for i in range(number_clients):
self.assertEqual(placement_manager.get_servers(clients[i]),
[(servers[i % number_servers], 1.0)])
for i in range(number_servers):
served_clients = [
clients[j] for j in range(i, number_clients, number_servers)
]
self.assertEqual(
placement_manager.get_clients_served_by(servers[i]),
{client: 1.0
for client in served_clients})
self.assertEqual(servers[i].used_capacity,
sum(client.demand for client in served_clients))
def client_loop():
print("-- Available commands:")
CM = ClientManager()
while True:
choice = input(">> [L]ogin, [C]reate new Client account, e[x]it: ")
if choice.lower().strip() not in LOGIN_CHOICES:
print(f"I do not recognize {choice} command.")
elif choice.lower().strip() == LOGIN_CHOICES[0]:
print(CM.data)
client = Client().sign_in(CM)
if client:
account_loop(client)
CM.save_file()
else:
print("Cannot perform logging in.")
elif choice.lower().strip() == LOGIN_CHOICES[1]:
Client().create(CM)
elif choice.lower().strip() == LOGIN_CHOICES[2]:
print("\nSee you next time!")
break
def test_create_clients(self):
number_clients = 100
demands = [random.randint(1, 100) for i in range(number_clients)]
client_manager = ClientManager()
clients = [client_manager.create_client(demand) for demand in demands]
for i in range(number_clients):
self.assertEqual(clients[i].id, i + 1)
self.assertEqual(clients[i].demand, demands[i])
def __get_clients_and_servers(self, demands, number_servers):
"""
Input: list with demands and integer number_servers.
Output: list with clients and list with servers.
"""
client_manager = ClientManager()
server_manager = ServerManager()
clients = [client_manager.create_client(demand) for demand in demands]
servers = [
server_manager.create_server() for i in range(number_servers)
]
return (clients, servers)
def read_input(file_name):
"""
Input: file name (string).
File format:
int algorithm (1 or 2)
int number of servers
list of int [client demands]
Reads file and outputs a list of clients, a list of servers and the algorithm.
"""
f = open(file_name, 'r')
client_manager = ClientManager()
server_manager = ServerManager()
algorithm = int(f.readline())
number_servers = int(f.readline())
servers = [server_manager.create_server() for i in range(number_servers)]
demands = map(int, f.readline().split())
clients = [client_manager.create_client(demand) for demand in demands]
return clients, servers, algorithm
def test_set_multiplicative_factors(self):
"""
Place each clients i in two servers:
server[0], with multiplicative_factor k, and servers[1] with multiplicative_factor 1.0-k.
"""
number_servers = 2
number_clients = 1000
server_manager = ServerManager()
client_manager = ClientManager()
servers = [
server_manager.create_server() for i in range(number_servers)
]
clients = [
client_manager.create_client(random.randint(10, 30))
for i in range(number_clients)
]
placement_manager = PlacementManager(servers)
multiplicative_factors = [
random.random() for i in range(number_clients)
]
for i in range(number_clients):
placement_manager.reset(clients[i:i + 1])
placement_manager.set_multiplicative_factor(
servers[0], clients[i:i + 1], multiplicative_factors[i])
placement_manager.set_multiplicative_factor(
servers[1], clients[i:i + 1], 1.0 - multiplicative_factors[i])
for i in range(number_clients):
retrieved_servers = placement_manager.get_servers(clients[i])
self.assertEqual(retrieved_servers[0][1],
multiplicative_factors[i])
self.assertEqual(retrieved_servers[1][1],
1.0 - multiplicative_factors[i])
retrieved_clients = placement_manager.get_clients_served_by(servers[0])
self.assertEqual(retrieved_clients, {
clients[i]: multiplicative_factors[i]
for i in range(number_clients)
})
retrieved_clients = placement_manager.get_clients_served_by(servers[1])
self.assertEqual(
retrieved_clients, {
clients[i]: 1.0 - multiplicative_factors[i]
for i in range(number_clients)
})
def test_place_in_single_server(self):
"""
All clients served by a single server.
Its used capacity equals the total client demand.
"""
server_manager = ServerManager()
client_manager = ClientManager()
server = server_manager.create_server()
number_clients = 100
demands = [random.randint(10, 30) for i in range(number_clients)]
clients = [client_manager.create_client(demand) for demand in demands]
placement_manager = PlacementManager([server])
for client in clients:
placement_manager.place_client(client, server)
for client in clients:
self.assertEqual(placement_manager.get_servers(client),
[(server, 1.0)])
self.assertEqual(placement_manager.get_clients_served_by(server),
{client: 1.0
for client in clients})
self.assertEqual(server.used_capacity, sum(demands))
from selenium.webdriver import Chrome, ChromeOptions
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from pymongo import MongoClient
import time
import unicodedata
import json
from client import ClientManager
client = ClientManager()
client.setup()
mongoClient = MongoClient("mongodb+srv://aurelien:[email protected]/lkd?retryWrites=true&w=majority")
db_lkd = mongoClient['lkd']
Peoples = db_lkd['peoples']
Companies = db_lkd['companies']
print(Peoples)
print(Companies)
class Search:
def __init__(self):
self.driver = client.driver
