def test_add_duplicate_user(self):
"""
Tests adding a user twice will throw an error.
"""
u1 = User("u1", 1)
network = UserNetwork()
network.add_user(u1)
self.assertRaises(DuplicateUserError, network.add_user, u1)
def test_double_remove_user(self):
"""
Tests double removing a user will throw an error.
"""
u1 = User("u1", 1)
network = UserNetwork()
network.add_user(u1)
network.remove_user(u1)
self.assertRaises(NonExistentUserError, network.remove_user, u1)
def event_handler():
user_network = UserNetwork()
user_network.follow(b'1', b'2')
user_network.follow(b'1', b'4')
return EventHandler({
b'1': Mock(),
b'2': Mock(),
b'3': Mock()
}, user_network)
def __init__(self):
"""
Creates a network of VisualUser objects and a directed graph to hold all the nodes and
connections for the user nodes.
"""
UserNetwork.__init__(self)
self.directed_graph = DirectedGraph(False, distance=20)
self.directed_graph.force = 1
self.canvas = None
self.ui = None
def remove_user(self, user):
"""
Removes a user from the network and removes the edges for the user's node from the graph.
:param user: User to remove
:type user: VisualUser
:return: None
"""
UserNetwork.remove_user(self, user)
self.directed_graph.remove(user.node)
for edge in user.edges:
edge_to_remove = self.directed_graph.edge(edge.node1.id, edge.node2.id)
self.directed_graph.remove(edge_to_remove)
def add_user(self, user):
"""
Adds the user to the user network and then adds a node to the user graph.
:param user: user to be added
:type user: VisualUser
:return: None
"""
UserNetwork.add_user(self, user)
self.directed_graph.add_node(user.node)
for edge in user.edges:
self.directed_graph.add_edge(edge.node1, edge.node2, weight=edge.weight,
stroke=edge.stroke, strokewidth=edge.strokewidth)
def test_add_user(self):
"""
Tests adding a user to a network.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
network = UserNetwork()
network.add_user(u1)
self.assertEqual(len(network.users), 1)
self.assertTrue(u1 in network.users)
network.add_user(u2)
self.assertEqual(len(network.users), 2)
self.assertTrue(u1 in network.users)
self.assertTrue(u2 in network.users)
def should_follow_unfollow():
network = UserNetwork()
network.follow(1, 2)
network.follow(1, 3)
network.follow(2, 3)
assert network[1] == {2, 3}
assert network[3] == set()
assert network[2] == {3}
network.unfollow(1, 3)
network.unfollow(1, 3) # no error
assert network[1] == {2}
def should_follow_unfollow():
network = UserNetwork()
network.follow(1, 2)
network.follow(1, 3)
network.follow(2, 3)
assert network[1] == {2, 3}
assert network[3] == set()
assert network[2] == {3}
network.unfollow(1, 3)
network.unfollow(1, 3) # no error
assert network[1] == {2}
def test_remove_user(self):
"""
Tests removing a user from a network.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.remove_user(u1)
self.assertEqual(len(network.users), 1)
self.assertTrue(u2 in network.users)
self.assertFalse(u1 in network.users)
network.remove_user(u2)
self.assertEqual(len(network.users), 0)
self.assertFalse(u2 in network.users)
self.assertFalse(u1 in network.users)
def test_basic_total_infection(self):
"""
Basic test of the total infection algorithm. There are 3 users such that user 1 coaches
user 2 and user 2 coaches user 3. All of the users should be infected.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
u3 = User("u3", 1)
u1.add_student(u2)
u2.add_student(u3)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.add_user(u3)
network.total_infection(u1, 2)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 2)
self.assertEqual(u3.version, 2)
network.total_infection(u2, 3)
self.assertEqual(u1.version, 3)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 3)
network.total_infection(u2, 4)
self.assertEqual(u1.version, 4)
self.assertEqual(u2.version, 4)
self.assertEqual(u3.version, 4)
#!/usr/bin/python
import socket
from threading import Thread
from event_handler import EventHandler
from message_queue import MessageQueue
from user_network import UserNetwork
users = {}
queue = MessageQueue()
event_handler = EventHandler(users, UserNetwork())
def bind_server(port, queue_len=1):
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind(('localhost', port))
serversocket.listen(queue_len)
return serversocket
def event_listener(port=9090):
serversocket = bind_server(port)
data = None
clientsocket = None
while True:
try:
if not data:
if clientsocket:
print(
"Event stream has stopped. Press Ctrl-C to stop the server"
)
clientsocket.close()
def event_handler():
user_network = UserNetwork()
user_network.follow(b'1', b'2')
user_network.follow(b'1', b'4')
return EventHandler({b'1': Mock(), b'2': Mock(), b'3': Mock()}, user_network)
def test_unconnected_limited_infection(self):
"""
Tests the limited infection algorithm with a group of 3 unconnected users.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
u3 = User("u3", 1)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.add_user(u3)
network.limited_infection(u1, 3, 2)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 2)
self.assertEqual(u3.version, 2)
network.limited_infection(u2, 3, 3)
self.assertEqual(u1.version, 3)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 3)
network.limited_infection(u3, 3, 4)
self.assertEqual(u1.version, 4)
self.assertEqual(u2.version, 4)
self.assertEqual(u3.version, 4)
network.limited_infection(u2, 2, 5)
self.assertEqual(u2.version, 5)
# One or other but not both
self.assertNotEqual(u1.version, u3.version)
self.assertTrue(u1.version == 5 or u3.version == 5)
def case_1_setup(self):
A = User("A", 1)
B = User("B", 1)
C = User("C", 1)
D = User("D", 1)
E = User("E", 1)
F = User("F", 1)
G = User("G", 1)
H = User("H", 1)
I = User("I", 1)
J = User("J", 1)
A.add_student(B)
A.add_student(C)
A.add_student(D)
B.add_student(E)
B.add_student(F)
C.add_student(F)
D.add_student(G)
J.add_coach(H)
J.add_coach(I)
network = UserNetwork()
network.add_user(A)
network.add_user(B)
network.add_user(C)
network.add_user(D)
network.add_user(E)
network.add_user(F)
network.add_user(G)
network.add_user(H)
network.add_user(I)
network.add_user(J)
return {"A": A, "B": B, "C": C, "D": D, "E": E, "F": F, "G": G,
"H": H, "I": I, "J": J}, network
def test_basic_limited_infection(self):
"""
Tests the limited infection algorithm on a network of 3 users such that user 1 coaches user 2 and
user 2 coaches user 3.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
u3 = User("u3", 1)
u1.add_student(u2)
u2.add_student(u3)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.add_user(u3)
network.limited_infection(u1, 2, 2)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 2)
self.assertEqual(u3.version, 1)
network.limited_infection(u2, 2, 3)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 3)
# Make sure it finds user w/ most infected students
network.limited_infection(u3, 2, 4)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 4)
self.assertEqual(u3.version, 4)
def test_some_connected_total_infection(self):
"""
Tests total infection of a network where only some of the users are connected to each other.
Each time the algorithm is called, only one connected portion of the network should be infected.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
u3 = User("u3", 1)
u4 = User("u4", 1)
u5 = User("u5", 1)
u6 = User("u6", 1)
u1.add_student(u2)
u1.add_student(u3)
u2.add_student(u4)
u5.add_student(u6)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.add_user(u3)
network.add_user(u4)
network.add_user(u5)
network.add_user(u6)
network.total_infection(u1, 2)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 2)
self.assertEqual(u3.version, 2)
self.assertEqual(u4.version, 2)
self.assertEqual(u5.version, 1)
self.assertEqual(u6.version, 1)
network.total_infection(u2, 3)
self.assertEqual(u1.version, 3)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 3)
self.assertEqual(u4.version, 3)
self.assertEqual(u5.version, 1)
self.assertEqual(u6.version, 1)
network.total_infection(u4, 4)
self.assertEqual(u1.version, 4)
self.assertEqual(u2.version, 4)
self.assertEqual(u3.version, 4)
self.assertEqual(u4.version, 4)
self.assertEqual(u5.version, 1)
self.assertEqual(u6.version, 1)
network.total_infection(u5, 5)
self.assertEqual(u1.version, 4)
self.assertEqual(u2.version, 4)
self.assertEqual(u3.version, 4)
self.assertEqual(u4.version, 4)
self.assertEqual(u5.version, 5)
self.assertEqual(u6.version, 5)
def test_unconnected_total_infection(self):
"""
Tests the total infection algorithm with 3 unconnected users.
Each time the algorithm is called, only one user should be infected.
"""
u1 = User("u1", 1)
u2 = User("u2", 1)
u3 = User("u3", 1)
network = UserNetwork()
network.add_user(u1)
network.add_user(u2)
network.add_user(u3)
network.total_infection(u1, 2)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 1)
self.assertEqual(u3.version, 1)
network.total_infection(u2, 3)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 1)
network.total_infection(u3, 4)
self.assertEqual(u1.version, 2)
self.assertEqual(u2.version, 3)
self.assertEqual(u3.version, 4)
