def setUp(self):
state = Follower()
self.oserver = Server(0, state, [], [])
state = Candidate()
self.server = Server(1, state, [], [self.oserver])
self.oserver._neighbors.append(self.server)
class TestLeaderServer(unittest.TestCase):
### Doing the initial setup for tests ##########
def setUp(self):
followers = []
for i in range(1, 4):
state = Follower()
followers.append(Server(i, state, [], []))
state = Leader()
self.leader = Server(0, state, [], followers)
for i in followers:
i._neighbors.append(self.leader)
##### Unit test to send heart beat to all the neighbours ##############
def test_leader_server_sends_heartbeat_to_all_neighbors(self):
self._perform_hearbeat()
self.assertEquals({1: 0, 2: 0, 3: 0}, self.leader._state._nextIndexes)
##### Unit test to ensure logs are getting committed to the neighbours ######
def test_leader_server_sends_messages_to_append_neighbours_logs(self):
self._perform_hearbeat()
msg = AppendEntriesMessage(
0, None, 1, {
"prevLogIndex": 0,
"prevLogTerm": 0,
"leaderCommit": 1,
"entries": [{
"term": 1,
"value": 800
}]
})
self.leader.send_message(msg)
for i in self.leader._neighbors:
i.on_message(i.get_message())
for i in self.leader._neighbors:
self.assertEquals([{"term": 1, "value": 800}], i._log)
####### Function to simulate performing heartbeat for the unit test ############
def _perform_hearbeat(self):
self.leader._state._send_heart_beat()
for i in self.leader._neighbors:
i.on_message(i.get_message())
for i in self.leader._board:
self.leader.on_message(i)
class TestCandidateServer(unittest.TestCase):
### Doing the initial setup for tests ##########
def setUp(self):
state = Follower()
self.oserver = Server(0, state, [], [])
state = Candidate()
self.server = Server(1, state, [], [self.oserver])
self.oserver._neighbors.append(self.server)
# unit test to check if communication between candidate and follower
def test_candidate_can_communicate_with_the_follower(self):
self.assertEquals(1, len(self.oserver._board))
self.oserver.on_message(self.oserver.get_message())
self.assertEquals(1, len(self.server._board))
self.assertEquals(True, self.server.get_message().data["response"])
### Candidate starting the election and gets vote from majority ##############
def test_candidate_server_wins_election(self):
state = Follower()
server0 = Server(0, state, [], [])
state = Follower()
server3 = Server(3, state, [], [])
state = Follower()
oserver = Server(1, state, [], [])
state = Candidate()
server = Server(2, state, [], [oserver, server0, server3])
server0._neighbors.append(server)
oserver._neighbors.append(server)
server3._neighbors.append(server)
oserver.on_message(oserver.get_message())
server0.on_message(server0.get_message())
server3.on_message(server3.get_message())
server._total_nodes = 4
server.on_message(server.get_message())
server.on_message(server.get_message())
self.assertEquals(type(server._state), Leader)
def setUp(self):
followers = []
for i in range(1, 4):
state = Follower()
followers.append(Server(i, state, [], []))
state = Leader()
self.leader = Server(0, state, [], followers)
for i in followers:
i._neighbors.append(self.leader)
class TestFollowerServer(unittest.TestCase):
### Doing the initial setup for tests ##########
def setUp(self):
state = Follower()
self.oserver = Server(0, state, [], [])
state = Follower()
self.server = Server(1, state, [], [self.oserver])
## Unit test to send heartbeart message to neighbours ################
def test_follower_server_on_message(self):
input_message = AppendEntriesMessage(0, 1, 10, {})
self.server.on_message(input_message)
self.assertEquals(10, self.server._currentTerm)
## Unit test to reject message with lesser term ###########
def test_follower_server_on_receive_message_with_lesser_term(self):
input_message = AppendEntriesMessage(0, 1, -1, {})
self.server.on_message(input_message)
self.assertEquals(False, self.oserver.get_message().data["response"])
#### Unit test to append log to an initial empty log##################
def test_follower_server_on_receiving_message_to_empty_logs(self):
msg = AppendEntriesMessage(
0, 1, 2, {
"prevLogIndex": 0,
"prevLogTerm": 100,
"leaderCommit": 1,
"entries": [{
"term": 1,
"value": 100
}]
})
self.server.on_message(msg)
self.assertEquals({"term": 1, "value": 100}, self.server._log[0])
## Unit test to test if follower is receiving message from candidate ######
def test_follower_server_on_receive_request_for_voting(self):
msg = RequestVoteMessage(0, 1, 2, {
"lastLogIndex": 0,
"lastLogTerm": 0,
"entries": []
})
self.server.on_message(msg)
self.assertEquals(0, self.server._state._last_vote)
self.assertEquals(True, self.oserver.get_message().data["response"])
message_data = "the number now is" + str(i)
followers[1].send_data(message_data)
print("the message has been sent")
time.sleep(1)
print("\n\nCreating four servers with names ranging from 0-3")
# Create Servers
followers = []
for name in range(4):
## Each server has a state out of (Candidate, Follower, Leader)
## Initially each candidate starts with follower state
state = Follower()
server = Server(name, state, [], [])
## Appending all neighbours to the current server
for follower in followers:
follower._neighbors.append(server)
server._neighbors.append(follower)
## Attaching a thread to the server
followers.append(server)
thread = Thread(target=serverFunction, args=(name, ))
thread.start()
print("Started server with name ", name)
print("\nWait until first timer timesout")
thread = Thread(target=checkMesages, args=())
thread.start()
def test_candidate_server_wins_election(self):
state = Follower()
server0 = Server(0, state, [], [])
state = Follower()
server3 = Server(3, state, [], [])
state = Follower()
oserver = Server(1, state, [], [])
state = Candidate()
server = Server(2, state, [], [oserver, server0, server3])
server0._neighbors.append(server)
oserver._neighbors.append(server)
server3._neighbors.append(server)
oserver.on_message(oserver.get_message())
server0.on_message(server0.get_message())
server3.on_message(server3.get_message())
server._total_nodes = 4
server.on_message(server.get_message())
server.on_message(server.get_message())
self.assertEquals(type(server._state), Leader)
def setUp(self):
state = Follower()
self.oserver = Server(0, state, [], [])
state = Follower()
self.server = Server(1, state, [], [self.oserver])