game_machine 0.0.10 → 0.0.11

data/spec/client_manager_spec.rb

@@ -55,7 +55,7 @@ module GameMachine
 
     let(:client_connection) do
       MessageLib::ClientConnection.new.set_id(client_name).set_gateway('udp').
-        set_server('server')
+        set_server('server').set_type('cluster')
     end
 
     let('local_player_message') do
@@ -91,7 +91,7 @@ module GameMachine
         subject.local_clients[client_name] = client_connection
         subject.players[player_id] = client_name
         subject.class.local_players[player_id] = true
-        actor_ref.stub(:tell)
+        allow(actor_ref).to receive(:tell)
         expect(Actor::Base).to receive(:find).with(player_id).and_return(actor_ref)
         ClientManager.send_to_player(local_player_message)
       end
@@ -99,7 +99,7 @@ module GameMachine
       it "should send message to remote manager if player is remote" do
         subject.remote_clients[client_name] = actor_ref
         subject.players[player_id] = client_name
-        ClientManager.stub(:find).and_return(actor_ref)
+        allow(ClientManager).to receive(:find).and_return(actor_ref)
         expect(actor_ref).to receive(:tell).with(remote_player_message)
         ClientManager.send_to_player(remote_player_message)
       end
@@ -108,30 +108,30 @@ module GameMachine
     describe "#process_client_event" do
       it "on connect should set players entry" do
         subject.on_receive(client_connected_event)
-        expect(subject.players.has_key?(player_id)).to be_true
+        expect(subject.players.has_key?(player_id)).to be_truthy
       end
 
       it "on connect should set remote_clients entry" do
         subject.on_receive(client_connected_event)
-        expect(subject.remote_clients.has_key?(client_name)).to be_true
+        expect(subject.remote_clients.has_key?(client_name)).to be_truthy
       end
 
       it "on disconnect event should remove remote client reference" do
         subject.remote_clients[client_name] = true
         subject.on_receive(client_disconnected_event)
-        expect(subject.remote_clients.has_key?(client_name)).to be_false
+        expect(subject.remote_clients.has_key?(client_name)).to be_falsey
       end
     end
 
     describe "#register_sender" do
       it "should add local client entry if client" do
         subject.on_receive(client_register)
-        expect(subject.local_clients.has_key?(client_name)).to be_true
+        expect(subject.local_clients.has_key?(client_name)).to be_truthy
       end
 
       it "should add local actor entry if actor" do
         subject.on_receive(actor_register)
-        expect(subject.local_actors.has_key?(actor_name)).to be_true
+        expect(subject.local_actors.has_key?(actor_name)).to be_truthy
       end
 
       it "client register should call send_client_event" do
@@ -155,7 +155,7 @@ module GameMachine
       it "removes local client reference" do
         subject.local_clients[client_name] = true
         subject.on_receive(client_unregister)
-        expect(subject.local_clients.has_key?(client_name)).to be_false
+        expect(subject.local_clients.has_key?(client_name)).to be_falsey
       end
 
       it "should not send client event for local connenction" do

data/spec/commands/chat_commands_spec.rb

@@ -9,7 +9,7 @@ module GameMachine
       subject{ChatCommands.new}
 
       before(:each) do
-        GameSystems::ChatManager.stub(:find).and_return(actor_ref)
+        allow(GameSystems::ChatManager).to receive(:find).and_return(actor_ref)
       end
 
       describe "#send_private_message" do

data/spec/commands/datastore_commands_spec.rb

@@ -20,11 +20,11 @@ module GameMachine
       subject{DatastoreCommands.new}
 
       before(:each) do
-        subject.define_dbproc(:test1) do |current_entity,update_entity|
+        subject.define_dbproc(:test1) do |id,current_entity,update_entity|
           expect(update_entity).to eql(entity)
           current_entity
         end
-        subject.define_dbproc(:test2) do |current_entity,update_entity|
+        subject.define_dbproc(:test2) do |id,current_entity,update_entity|
           current_entity.set_entity_type('dunno')
           current_entity
         end
@@ -32,7 +32,7 @@ module GameMachine
 
       describe "#put" do
         it "sets the value" do
-          subject.put(entity).should be_true
+          expect(subject.put(entity)).to be_truthy
         end
       end
 
@@ -42,8 +42,8 @@ module GameMachine
           sleep 0.100
             
           result = subject.call_dbproc(:test1, entity.get_id,entity,true)
-          result.should be_kind_of(MessageLib::Entity)
-          result.get_id.should == entity.get_id
+          expect(result).to be_kind_of(MessageLib::Entity)
+          expect(result.get_id).to eq(entity.get_id)
         end
 
         it "returns updated entity" do
@@ -51,31 +51,27 @@ module GameMachine
           sleep 0.100
             
           result = subject.call_dbproc(:test2, entity.get_id,entity,true)
-          result.get_entity_type.should == 'dunno'
+          expect(result.get_entity_type).to eq('dunno')
         end
 
         it "returns true when called with blocking=false" do
           subject.put(entity)
           sleep 0.100
             
-          subject.call_dbproc(:test1, entity.get_id,entity,false).should be_true
+          expect(subject.call_dbproc(:test1, entity.get_id,entity,false)).to be_truthy
         end
 
-        it "if called with an entity id that does not exist, it creates it" do
-          returned_entity = subject.call_dbproc(:test1, 'blah',entity,true)
-          expect(returned_entity.id).to eql('blah')
-        end
       end
 
       describe "#get" do
         it "should return false if object does not exist" do
-          subject.get('xx').should be_false
+          expect(subject.get('xx')).to be_falsey
         end
 
         it "should return object if exists" do
           subject.put(entity)
           sleep 0.100
-          subject.get('1').should == entity
+          expect(subject.get('1')).to eq(entity)
         end
       end
 
@@ -83,7 +79,7 @@ module GameMachine
         it "removes the entity from the data store" do
           subject.put(entity)
           subject.delete(entity.id)
-          subject.get('1').should be_false
+          expect(subject.get('1')).to be_falsey
         end
       end
     end

data/spec/commands/navigation_commands_spec.rb

@@ -11,9 +11,9 @@ module GameMachine
       subject{NavigationCommands.new}
 
       before(:each) do
-        Navigation::DetourPath.stub(:query_ref).and_return(query_ref)
-        Navigation::DetourNavmesh.stub(:create).and_return(navmesh)
-        Navigation::DetourNavmesh.stub(:find).and_return(navmesh)
+        allow(Navigation::DetourPath).to receive(:query_ref).and_return(query_ref)
+        allow(Navigation::DetourNavmesh).to receive(:create).and_return(navmesh)
+        allow(Navigation::DetourNavmesh).to receive(:find).and_return(navmesh)
       end
 
       describe "#load_navmesh" do

data/spec/commands/player_commands_spec.rb

@@ -22,7 +22,7 @@ module GameMachine
       describe "player" do
         describe "#send_message" do
           before(:each) do
-            ClientManager.stub(:find).and_return(actor_ref)
+            allow(ClientManager).to receive(:find).and_return(actor_ref)
           end
 
           it "sends component to player wrapped in entity" do

data/spec/game_systems/agents/controller_spec.rb

@@ -58,21 +58,21 @@ module GameMachine
             my_agents = agents.clone
             my_agents.delete(:agent1)
             my_agents.delete(:agent2)
-            subject.stub(:local_agents).and_return(my_agents)
+            allow(subject).to receive(:local_agents).and_return(my_agents)
             subject.update_agents
             expect(subject.children.size).to eq 3
-            expect(subject.children.has_key?(:agent1)).to be_false
-            expect(subject.children.has_key?(:agent2)).to be_false
+            expect(subject.children.has_key?(:agent1)).to be_falsey
+            expect(subject.children.has_key?(:agent2)).to be_falsey
           end
 
           it "should create new children it becomes responsible for" do
             my_agents = agents.clone
             my_agents[:agent6] = 'TestAgent'
-            subject.stub(:agent_config).and_return(my_agents)
-            subject.stub(:local_agents).and_return(my_agents)
+            allow(subject).to receive(:agent_config).and_return(my_agents)
+            allow(subject).to receive(:local_agents).and_return(my_agents)
             subject.update_agents
             expect(subject.children.size).to eq 6
-            expect(subject.children.has_key?(:agent6)).to be_true
+            expect(subject.children.has_key?(:agent6)).to be_truthy
           end
         end
 

data/spec/game_systems/chat_manager_spec.rb

@@ -25,7 +25,7 @@ module GameMachine
         game_message.to_entity
       end
 
-      let(:actor_builder) {mock('Actor::Builder', :with_parent => actor_builder, :start => true)}
+      let(:actor_builder) {double('Actor::Builder', :with_parent => actor_builder, :start => true)}
 
       let(:chat_invite) do
         chat = Commands::ChatCommands.new

data/spec/game_systems/chat_spec.rb

@@ -60,9 +60,9 @@ module GameMachine
       end
 
       before(:each) do
-        Chat.any_instance.stub(:load_state)
+        allow_any_instance_of(Chat).to receive(:load_state)
         Actor::Builder.new(GameSystems::Chat,player_id).start
-        MessageQueue.stub(:find).and_return(actor_ref)
+        allow(MessageQueue).to receive(:find).and_return(actor_ref)
         commands.datastore.delete("chat_topic_#{topic}")
       end
 
@@ -76,7 +76,7 @@ module GameMachine
         end
 
         it "joining my own channel should work" do
-          channel_name = "priv/#{player_id}/test"
+          channel_name = "priv_#{player_id}_test"
           join_message = commands.chat.join_message(channel_name,player_id)
           expect(subject).to receive(:join_channel)
           subject.on_receive(join_message)
@@ -101,10 +101,8 @@ module GameMachine
 
       describe "subscribers list updates" do
         it "joining a channel adds player to subscriber list" do
+          expect(subject).to receive(:add_subscriber)
           subject.on_receive(join_request)
-          subscribers = Chat.subscribers_for_topic(topic)
-          expect(subscribers.get_subscriber_id_count).to eql(1)
-          expect(subscribers.get_subscriber_id_list.first).to eql(player_id)
           subject.on_receive(leave_request)
         end
 
@@ -120,7 +118,7 @@ module GameMachine
         it "joining a channel with flags should persist the flag" do
           subject.on_receive(join_request_with_flags)
           topic_flags = subject.get_flags.fetch(topic,[])
-          topic_flags.include?('subscribers').should be_true
+          expect(topic_flags.include?('subscribers')).to be_truthy
         end
 
         it "chat status should add subscribers to channel if flag is set" do
@@ -135,46 +133,46 @@ module GameMachine
         it "joining a channel should persist subscriptions" do
           subject.on_receive(join_request_with_flags)
           subscriptions = subject.get_subscriptions
-          subscriptions.include?(topic).should be_true
+          expect(subscriptions.include?(topic)).to be_truthy
         end
       end
 
       describe "joining and leaving channels" do
         it "processes the entity as a leave channel request" do
-          subject.should_receive(:leave_channels)
+          expect(subject).to receive(:leave_channels)
           subject.on_receive(leave_request)
         end
 
         it "sends an unsubscribe message to message queue" do
           subject.on_receive(join_request)
-          actor_ref.should_receive(:tell).with(kind_of(MessageLib::Unsubscribe),anything())
+          expect(actor_ref).to receive(:tell).with(kind_of(MessageLib::Unsubscribe),anything())
           subject.on_receive(leave_request)
         end
 
         it "processes the entity as a join channel request" do
-          subject.should_receive(:join_channels)
+          expect(subject).to receive(:join_channels)
           subject.on_receive(join_request)
         end
 
         it "sends a subscribe message to message queue" do
-          actor_ref.should_receive(:tell).exactly(1).times
+          expect(actor_ref).to receive(:tell).exactly(1).times
           subject.on_receive(join_request)
         end
 
         it "processes multiple requests in a single message" do
-          subject.should_receive(:join_channels).once
-          subject.should_receive(:leave_channels).once
-          subject.should_receive(:send_message).once
+          expect(subject).to receive(:join_channels).once
+          expect(subject).to receive(:leave_channels).once
+          expect(subject).to receive(:send_message).once
           subject.on_receive(all_requests)
         end
 
         it "send a private chat message" do
-          subject.should_receive(:send_private_message).once
+          expect(subject).to receive(:send_private_message).once
           subject.on_receive(private_chat_request)
         end
 
         it "send a group chat message" do
-          subject.should_receive(:send_group_message).once
+          expect(subject).to receive(:send_group_message).once
           subject.on_receive(public_chat_request)
         end
 

data/spec/game_systems/region_manager_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 module GameMachine
   module GameSystems
+    include Models
 
     class Zone2Manager < Actor::Base
       def on_receive(message);end
@@ -42,14 +43,20 @@ module GameMachine
         ref.underlying_actor
       end
 
+      before(:each) do
+        allow_any_instance_of(RegionManager).to receive(:post_init)
+        subject.regions = {}
+        subject.servers = {}
+      end
+
       describe "#assign_servers" do
         it "should assign servers to regions that have none" do
-          subject.stub(:regions).and_return(regions)
-          ClusterMonitor.stub(:cluster_members).and_return(cluster_members)
+          allow(subject).to receive(:regions).and_return(regions)
+          allow(ClusterMonitor).to receive(:cluster_members).and_return(cluster_members)
           expect(region1).to receive(:server=)
           expect(region2).to receive(:server=)
-          expect(region1).to receive(:save)
-          expect(region2).to receive(:save)
+          expect(region1).to receive(:save!)
+          expect(region2).to receive(:save!)
           subject.assign_servers
           expect(subject.servers[server1_address]).to eq region1.name
           expect(subject.servers[server2_address]).to eq region2.name
@@ -59,9 +66,9 @@ module GameMachine
 
       describe "#notify_managers" do
         it "should send message to manager of each region" do
-          subject.stub(:regions).and_return(regions)
-          region1.stub(:server).and_return(server1_address)
-          region2.stub(:server).and_return(server2_address)
+          allow(subject).to receive(:regions).and_return(regions)
+          allow(region1).to receive(:server).and_return(server1_address)
+          allow(region2).to receive(:server).and_return(server2_address)
           expect(GameSystems::Zone1Manager).to receive(:find_by_address).
             with(server1_address).  and_return(actor_ref)
           expect(GameSystems::Zone2Manager).to receive(:find_by_address).
@@ -73,25 +80,27 @@ module GameMachine
       describe "#load_from_config" do
         
         it "should create new regions that do not exist" do
-          expect(Models::Region).to receive(:find).
-            with('zone1',5000).and_return(nil)
-          expect(Models::Region).to receive(:find).
-            with('zone2',5000).and_return(nil)
+          expect(Region).to receive(:find!).
+            with('zone1').and_return(nil)
+          expect(Region).to receive(:find!).
+            with('zone2').and_return(nil)
 
-          expect(Models::Region).to receive(:new).
+          expect(Region).to receive(:new).
             with(:id => 'zone1', :name => 'zone1', :manager => zone1_manager).and_return(region1)
-          expect(Models::Region).to receive(:new).
+          expect(Region).to receive(:new).
             with(:id => 'zone2', :name => 'zone2', :manager => zone2_manager).and_return(region2)
 
-          expect(region1).to receive(:save)
-          expect(region2).to receive(:save)
+          expect(region1).to receive(:save!)
+          expect(region2).to receive(:save!)
+          subject.load_from_config
           expect(subject.regions['zone1']).to eq region1
           expect(subject.regions['zone2']).to eq region2
         end
         
         it "should load regions that exist" do
-          expect(Models::Region).to receive(:find).with('zone1',5000).and_return(region1)
-          expect(Models::Region).to receive(:find).with('zone2',5000).and_return(region2)
+          expect(Region).to receive(:find!).with('zone1').and_return(region1)
+          expect(Region).to receive(:find!).with('zone2').and_return(region2)
+          subject.load_from_config
           expect(subject.regions['zone1']).to eq region1
           expect(subject.regions['zone2']).to eq region2
         end
@@ -101,7 +110,7 @@ module GameMachine
 
         context "nodes have not changed" do
           it "should not unassign servers from regions" do
-            ClusterMonitor.stub(:cluster_members).and_return(cluster_members)
+            allow(ClusterMonitor).to receive(:cluster_members).and_return(cluster_members)
             subject.unassign_down_servers
             expect(region1).to_not receive(:save)
             expect(region2).to_not receive(:save)
@@ -111,9 +120,10 @@ module GameMachine
         context "node has been downed" do
 
           before(:each) do
+            subject.load_from_config
             subject.regions['zone1'].server = server2_address
             subject.servers[server2_address] = 'zone1'
-            ClusterMonitor.stub(:cluster_members).and_return(cluster_with_down_members)
+            allow(ClusterMonitor).to receive(:cluster_members).and_return(cluster_with_down_members)
           end
 
           it "should set region server to nil" do
@@ -123,11 +133,11 @@ module GameMachine
 
           it "should remove servers entry" do
             subject.unassign_down_servers
-            expect(subject.servers.has_key?(server2_address)).to be_false
+            expect(subject.servers.has_key?(server2_address)).to be_falsey
           end
 
           it "should save region" do
-            expect(subject.regions['zone1']).to receive(:save)
+            expect(subject.regions['zone1']).to receive(:save!)
             subject.unassign_down_servers
           end
         end

data/spec/game_systems/team_manager_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+module GameMachine
+  module GameSystems
+    include Models
+
+    describe TeamManager do
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      let(:player_id) {'player'}
+      let(:player2) {'player2'}
+      let(:team_name) {'team1'}
+      let(:team_name2) {'team2'}
+      let(:team_members) {[player_id]}
+      let(:invite_id) {'invite'}
+
+      let(:team) do
+        Team.new(:owner => player_id, :name => team_name, :access => 'public', :members => team_members)
+      end
+
+      let(:team_two_members) do
+        Team.new(:owner => player_id, :name => team_name2, :access => 'public', :members => [player_id,player2])
+      end
+
+      let(:team_invite) do
+        TeamInvite.new(:name => team_name, :invitee => player_id)
+      end
+
+      let(:team_accept_invite) do
+        TeamAcceptInvite.new(:name => team_name, :invitee => player2, :invite_id => invite_id)
+      end
+
+      let(:private_team) do
+        Team.new(:owner => player_id, :name => team_name, :access => 'private', :members => team_members)
+      end
+
+      let(:destroy_team) do
+        DestroyTeam.new(:name => team_name)
+      end
+
+      let(:leave_team) do
+        LeaveTeam.new(:name => team_name)
+      end
+
+      let(:join_team) do
+        JoinTeam.new(:name => team_name)
+      end
+
+      let(:create_team) do
+        CreateTeam.new(:owner => player_id, :name => team_name, :access => 'public')
+      end
+
+      let(:create_private_team) do
+        CreateTeam.new(:owner => player_id, :name => team_name, :access => 'private')
+      end
+
+      let(:start_match) do
+        StartMatch.new(:game_handler => nil, :team_names => [team_name,team_name2])
+      end
+
+      let(:end_match) do
+        EndMatch.new(:match_id => 'team1_team2')
+      end
+
+      let(:match) {double('Match')}
+      let(:actor_ref) {double('ActorRef', :tell => true)}
+
+      subject do
+        ref = Actor::Builder.new(TeamManager).with_name('team_manager_test').test_ref
+        ref.underlying_actor
+      end
+
+      before(:each) do
+        allow_any_instance_of(Commands::PlayerCommands).to receive(:send_message).and_return(true)
+        allow_any_instance_of(Commands::MiscCommands).to receive(:client_manager_register).and_return(true)
+      end
+
+      describe "#create_team" do
+
+        before(:each) do
+          allow(subject).to receive(:send_team_joined).and_return(true)
+        end
+
+        it "should create a team" do
+          allow(Team).to receive(:find!).and_return(nil)
+          expect_any_instance_of(Team).to receive(:save!)
+          subject.on_receive(create_team)
+        end
+
+        it "should send chat join request" do
+          allow(Team).to receive(:find!).and_return(nil)
+          expect(subject).to receive(:join_chat).with(team_name,player_id)
+          subject.on_receive(create_team)
+        end
+
+        it "should not create a team if one exists" do
+          allow(Team).to receive(:find!).and_return(team)
+          expect(subject.create_team(create_team)).to be_falsey
+        end
+
+        it "should create invite id if private team" do
+          allow(Team).to receive(:find!).and_return(nil)
+          allow(subject).to receive(:team_id).and_return 'team_id'
+          expect(Uniqueid).to receive(:generate_token).with(team_name).and_return invite_id
+          subject.on_receive(create_private_team)
+        end
+      end
+
+      describe "#destroy_team" do
+        before(:each) do
+          allow(Team).to receive(:find!).and_return(team)
+        end
+
+        it "should delete the team" do
+          destroy_team.player_id = player_id
+          expect(team).to receive(:destroy!)
+          subject.on_receive(destroy_team)
+        end
+
+        it "should send a leave_chat for each member" do
+          destroy_team.player_id = player_id
+          expect(subject).to receive(:leave_chat).with(team.name,player_id)
+          subject.on_receive(destroy_team)
+        end
+
+        it "should destroy player_team" do
+          destroy_team.player_id = player_id
+          expect(subject).to receive(:destroy_player_team).with(player_id)
+          subject.on_receive(destroy_team)
+        end
+
+        it "should not delete the team if request is from non owner" do
+          destroy_team.player_id = player2
+          expect(team).to_not receive(:destroy!)
+          subject.on_receive(destroy_team)
+        end
+      end
+
+      describe "#leave_team" do
+
+        before(:each) do
+          allow(Team).to receive(:find!).and_return(team)
+        end
+
+        it "should destroy team if last member leaves" do
+          leave_team.player_id = player_id
+          expect(subject).to receive(:destroy_team)
+          expect(subject).to receive(:destroy_on_owner_leave?).and_return(false)
+          subject.on_receive(leave_team)
+        end
+
+        it "should reassign owner if owner leaves" do
+          allow(Team).to receive(:find!).and_return(team_two_members)
+          leave_team.player_id = player_id
+          allow(subject).to receive(:destroy_on_owner_leave?).and_return(false)
+          subject.on_receive(leave_team)
+          expect(team_two_members.owner).to eql(player2)
+        end
+
+        it "should remove member from team" do
+          leave_team.player_id = player2
+          subject.on_receive(leave_team)
+          expect(team.members.include?(player2)).to be_falsey
+        end
+
+        it "should destroy team if player is owner" do
+          leave_team.player_id = player_id
+          expect(subject).to receive(:destroy_team)
+          subject.on_receive(leave_team)
+        end
+
+        it "should call destroy_player_team with player id" do
+          leave_team.player_id = player_id
+          expect(subject).to receive(:destroy_player_team).with(player_id)
+          subject.on_receive(leave_team)
+        end
+      end
+
+      describe "#join_team" do
+
+        before(:each) do
+          allow(Team).to receive(:find!).and_return(team)
+        end
+
+        it "should add member to the team" do
+          join_team.player_id = player2
+          expect(team.members).to receive(:<<).with(player2)
+          subject.on_receive(join_team)
+        end
+
+        it "should send join_chat request for member" do
+          join_team.player_id = player2
+          expect(subject).to receive(:join_chat).with(team.name,player2)
+          subject.on_receive(join_team)
+        end
+
+        it "should not add member to team if access is private" do
+          allow(Team).to receive(:find!).and_return(private_team)
+          expect(subject).to_not receive(:create_player_team)
+          subject.on_receive(join_team)
+        end
+
+        it "should not join the same player twice" do
+          join_team.player_id = player2
+          subject.on_receive(join_team)
+          expect(team.members).to_not receive(:<<).with(player2)
+          subject.on_receive(join_team)
+        end
+
+        it "should resend team_joined message" do
+          join_team.player_id = player2
+          subject.on_receive(join_team)
+          expect(subject).to receive(:send_team_joined)
+          subject.on_receive(join_team)
+        end
+      end
+
+      describe "#team_invite" do
+
+        it "should forward the invite message to the invitee" do
+          allow(Team).to receive(:find!).and_return(team)
+          team_invite.player_id = player_id
+          expect_any_instance_of(Commands::PlayerCommands).to receive(:send_message)
+          subject.on_receive(team_invite)
+        end
+
+        it "should set the invite id to the team invite id" do
+          allow(Team).to receive(:find!).and_return(team)
+          team_invite.player_id = player_id
+          team.invite_id = 'blah'
+          expect(team_invite).to receive("invite_id=").with('blah')
+          subject.on_receive(team_invite)
+        end
+      end
+
+      describe "team_accept_invite" do
+
+        it "should add member to team with correct invite id" do
+          allow(Team).to receive(:find!).and_return(team)
+          team_invite.player_id = player_id
+          team.invite_id = invite_id
+          expect(subject).to receive(:join_team)
+          subject.on_receive(team_accept_invite)
+        end
+
+        it "should not add member to team with incorrect invite id" do
+          allow(Team).to receive(:find!).and_return(team)
+          team_invite.player_id = player_id
+          team.invite_id = 'bad invite'
+          expect(subject).to_not receive(:join_team)
+          subject.on_receive(team_accept_invite)
+        end
+      end
+
+      describe "#start_match" do
+        it "should create the match" do
+          allow(Team).to receive(:find!).with('team1').and_return(team)
+          allow(Team).to receive(:find!).with('team2').and_return(team_two_members)
+          expect(match).to receive(:save)
+          expect(Match).to receive(:new).
+            with(
+              :id => 'team1_team2',
+              :teams => [team,team_two_members],
+              :server => 'localhost',
+              :game_handler => nil
+          ).and_return(match)
+          subject.on_receive(start_match)
+        end
+
+        it "should save teams with match id" do
+          allow(Team).to receive(:find!).with('team1').and_return(team)
+          allow(Team).to receive(:find!).with('team2').and_return(team_two_members)
+          expect(team).to receive(:match_id=).with('team1_team2')
+          expect(team_two_members).to receive(:match_id=).with('team1_team2')
+          subject.on_receive(start_match)
+        end
+      end
+
+      describe "#end_match" do
+        it "should destroy the match" do
+          allow(match).to receive(:teams).and_return([team,team_two_members])
+          expect(Match).to receive(:find!).with('team1_team2').and_return(match)
+          expect(match).to receive(:destroy)
+          subject.on_receive(end_match)
+        end
+      end
+
+    end
+  end
+end