class Shared(object):
width = 500
height = 500
bot_id = Id(name="bot", version=1)
def setup(self):
self.world = World(self.width, self.height, False)
class TestBotRegistration(RegistrationSetup):
client_type = ClientType.BOT
client_id = Id(name="bot", version=1)
def test_registering_bots_are_associated_with_channels(self):
self.server._run_once()
bot = self.server._bots[0]
assert bot is not None
assert bot.event_channel is not None
assert bot.cmd_channel is not None
assert bot.tank_id == 0
def test_registering_bots_get_dedicated_channel_urls_and_game_info(self):
self.server._run_once()
bot = self.server._bots[0]
self.registration_channel.send.assert_called_once_with(
RegistrationReply(result=RegistrationResult.SUCCESS,
game_info=self.server.build_game_info(),
event_url=bot.event_channel.url,
cmd_url=bot.cmd_channel.url,
id=0))
def test_bot_cmd_channel_is_polled(self):
self.server._run_once()
self.reset_mock_channel(self.registration_channel)
self.server._run_once()
bot = self.server._bots[0]
bot.cmd_channel.ready.assert_called_once_with()
def test_bot_is_added_to_world(self):
self.server._run_once()
self.world.add_tank.assert_called_once_with(self.client_id, 0)
def __init__(self, server_url):
"""Initialize a new server proxy
:param server_url: The URL of the actual server being proxied
"""
zmq_context = zmq.Context.instance()
registration_socket = zmq_context.socket(zmq.REQ)
registration_socket.connect(server_url)
registration_socket.send(
serialize(
Registration(client_type=ClientType.VIEWER,
id=Id(name="viewer:%s:%s" %
(socket.gethostname(), uuid4()),
version=1))))
reply = deserialize(RegistrationReply, registration_socket.recv())
self._update_socket = zmq_context.socket(zmq.SUB)
self._update_socket.set(zmq.SUBSCRIBE, b"")
arena = reply.game_info.arena
self.arena = pygame.Rect(0, 0, arena.width, arena.height)
self.player_count = reply.game_info.player_count
event_url = reply.event_url
LOG.info("Subscribing to %s", event_url)
self._update_socket.connect(event_url)
self.entities = pygame.sprite.LayeredUpdates()
self.tanks = pygame.sprite.Group()
def setup(self):
super(TestStartedGame, self).setup()
for i in range(PLAYER_COUNT):
self.server._handle_bot_registration(
Registration(client_type=ClientType.BOT,
id=Id(name="bot", version=1)))
self.world.number_of_live_bots = PLAYER_COUNT
def setup(self):
super(TestGame, self).setup()
self.server._handle_bot_registration(
Registration(client_type=ClientType.BOT,
id=Id(name="bot", version=1)))
self.bot = self.server._bots[0]
self.bot._tank.status = BotStatus.IDLE
def test_game_started_after_fourth_bot(self):
# One from setup, and another three here
for i in range(PLAYER_COUNT - 1):
assert not self.server.started()
self.server._handle_bot_registration(
Registration(client_type=ClientType.BOT,
id=Id(name="bot", version=1)))
assert self.server.started()
def _register(self, server_url, zmq_context):
registration_socket = zmq_context.socket(zmq.REQ)
registration_socket.connect(server_url)
registration_socket.send(
serialize(
Registration(client_type=ClientType.BOT,
id=Id(name="clibot", version=1))))
reply = deserialize(RegistrationReply, registration_socket.recv())
return reply
def test_socket_with_special_class(self):
with patch.object(Channel, "url_scheme", self.test_url_scheme), \
patch.object(Channel, "url_wildcard", self.test_url_wildcard), \
patch.object(Channel, "_bind_socket", _test_bind):
req_socket = Channel(ChannelType.REQUEST, 1)
rep_socket = Channel(ChannelType.REPLY, 0, Registration)
value = Registration(client_type=ClientType.VIEWER, id=Id(name="test", version=1))
req_socket.send(value)
assert rep_socket.recv() == value
class TestViewerRegistration(RegistrationSetup):
client_type = ClientType.VIEWER
client_id = Id(name="viewer", version=1)
def test_registering_viewer_gets_generic_urls_and_game_info(self):
self.server._run_once()
self.registration_channel.send.assert_called_once_with(
RegistrationReply(result=RegistrationResult.SUCCESS,
game_info=self.server.build_game_info(),
event_url=self.server._viewer_channel.url))
def test_new_bots_are_refused_when_game_started(self):
self.server._handle_bot_registration(
Registration(client_type=ClientType.BOT,
id=Id(name="bot", version=1)))
game_info = GameInfo(arena=self.world.arena,
max_health=MAX_HEALTH,
bullet_damage=BULLET_DAMAGE,
player_count=PLAYER_COUNT,
tank_speed=TANK_SPEED,
rotation=ROTATION,
bullet_speed=BULLET_SPEED,
tank_radius=TANK_RADIUS,
bullet_radius=BULLET_RADIUS)
self.registration_channel.send.assert_called_with(
RegistrationReply(result=RegistrationResult.FAILURE,
game_info=game_info))
class Shared(object):
bot_id = Id(name="bot", version=1)
initial_x = 30
initial_y = 50
initial_direction = Point2(1, 0)
initial_turret = Point2(-1, 0)
@classmethod
def setup_class(cls):
cls.world = create_autospec(World)
cls.world.arena = Arena(width=500, height=500)
def setup(self):
self.tank = self._create_tank()
self.armour = Armour(self.tank, self.world)
self.other = Armour(self._create_tank(1, Point(x=250, y=250)),
self.world)
self.bullet = self._create_bullet()
self.missile = Missile(self.bullet, self.world, self.armour)
self.world.is_collision.return_value = False
self.world.reset_mock()
def _create_tank(self, tank_id=0, position=None):
if position is None:
position = Point(x=self.initial_x, y=self.initial_y)
return Tank(id=tank_id,
bot_id=self.bot_id,
position=position,
direction=to_point(self.initial_direction),
turret=to_point(self.initial_turret),
health=MAX_HEALTH,
status=BotStatus.IDLE)
def _create_bullet(self, bullet_id=0, position=None):
if position is None:
position = Point(x=self.initial_x, y=self.initial_y)
return Bullet(id=bullet_id,
position=position,
direction=to_point(self.initial_direction))