game_machine 0.0.8

data/spec/grid_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module GameMachine
+  describe Grid do
+
+    subject {Grid}
+
+    before(:each) do 
+      Grid.reset_grids
+    end
+
+    describe "#update_freqency_for" do
+      it "returns the update freqency for the named grid" do
+        Grid.load_from_config
+        expect(Grid.update_frequency_for('default')).to eq 1
+      end
+    end
+
+    describe "#load_from_config" do
+      it "should create grids from config" do
+        Grid.load_from_config
+        expect(Grid.config.has_key?('default')).to be_true
+      end
+    end
+
+    describe "#find_or_create" do
+      it "creates a grid if none exists for the given name" do
+        grid = subject.find_or_create('test')
+        expect(grid).to be_instance_of(JavaLib::Grid)
+      end
+
+      it "returns the same instance if already created" do
+        grid = subject.find_or_create('test')
+        expect(subject.find_or_create('test')).to eql(grid)
+      end
+    end
+  end
+end

data/spec/handlers/authentication_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module GameMachine
+  module Handlers
+    
+    describe Authentication do
+
+      let(:handler) {double('Handler', :tell => true)}
+      let(:actor_ref) {double('ActorRef', :ask => true)}
+      let(:player) {MessageLib::Player.new.set_id('player').set_authtoken('authorized')}
+
+      subject do
+        Authentication.new
+      end
+
+      describe "authenticating a player" do
+
+        context "player is authenticated" do
+          it "authenticates player with valid authtoken" do
+            expect(subject.authenticate!(player)).to be_true
+          end
+        end
+
+        context "player is not authenticated" do
+          it "does not authenticate player with invalid authtoken" do
+            player.set_authtoken('badtoken')
+            expect(subject.authenticate!(player)).to be_false
+          end
+        end
+
+
+      end
+
+    end
+  end
+end

data/spec/handlers/game_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module GameMachine
+  module Handlers
+    
+    describe Game do
+
+      let(:player) {MessageLib::Player.new}
+      let(:client_connection) {MessageLib::ClientConnection.new}
+
+      let(:leave_chat) do
+        MessageLib::Entity.new.set_leave_chat(MessageLib::LeaveChat.new).
+          set_player(player).set_client_connection(client_connection)
+      end
+
+      let(:bad_entity) {MessageLib::Entity.new.set_id('1').set_publish(MessageLib::Publish.new)}
+      let(:empty_entity) {MessageLib::Entity.new.set_id('1')}
+
+      let(:actor_ref) {double('DispatcherActor::Ref')}
+
+      describe "aspects" do
+        before(:each) do
+          Actor::Builder.new(Game).with_name('dispatch_test').start
+        end
+
+        it "dispatches entities to correct system" do
+          client_message = MessageLib::ClientMessage.new.add_entity(leave_chat)
+          GameSystems::ChatManager.stub(:find).and_return(actor_ref)
+          actor_ref.should_receive(:tell)
+          Game.should_receive_message(client_message,'dispatch_test') do
+            Game.find('dispatch_test').tell(client_message)
+          end
+        end
+
+        it "does not dispatch when aspect not found" do
+          client_message = MessageLib::ClientMessage.new.add_entity(empty_entity)
+          Game.should_receive_message(client_message,'dispatch_test') do
+            Game.find('dispatch_test').tell(client_message)
+          end
+        end
+
+      end
+
+    end
+
+  end
+end
+
+

data/spec/handlers/request_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module GameMachine
+  module Handlers
+    describe Request do
+
+      let(:player) {MessageLib::Player.new.set_id('1')}
+      let(:client_id) {'client1'}
+      let(:client_connection) {MessageLib::ClientConnection.new}
+
+      let(:entity) do
+       MessageLib::Entity.new.set_id('1')
+      end
+
+      let(:player_logout) do
+        MessageLib::PlayerLogout.new.set_player_id(player.id)
+      end
+
+      let(:client_message) do
+        MessageLib::ClientMessage.new.
+          set_client_connection(client_connection).
+          set_player(player).
+          add_entity(entity)
+      end
+
+      let(:actor_ref) {double('Actor::Ref', :tell => true)}
+
+      describe "#on_receive" do
+
+        before(:each) do
+          Actor::Builder.new(Request).with_name('test_request_handler').start
+        end
+
+        it "sets player on entities" do
+          message = client_message
+          entity = message.get_entity_list.first
+          entity.should_receive(:set_player).with(message.player)
+          Request.should_receive_message(message,'test_request_handler') do
+            Request.find('test_request_handler').tell(message)
+          end
+        end
+
+
+        it "calls unhandled if not a client message" do
+          Request.any_instance.should_receive(:unhandled).with('test')
+          Request.should_receive_message('test','test_request_handler') do
+            Request.find('test_request_handler').tell('test')
+          end
+        end
+
+        it "calls unhandled if player is not set" do
+          message = client_message
+          message.set_player(nil)
+          Request.any_instance.should_receive(:unhandled).with(message)
+          Request.should_receive_message(message,'test_request_handler') do
+            Request.find('test_request_handler').tell(message)
+          end
+        end
+
+      end
+
+
+    end
+  end
+end

data/spec/hashring_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module GameMachine
+  describe Hashring do
+
+    let(:buckets) {['server1','server2']}
+    let(:bucket_name) {'test_bucket'}
+
+    subject do
+      Hashring.new(buckets)
+    end
+
+    describe "#nodes" do
+      it "nodes should equal buckets" do
+        subject.nodes.sort.should == buckets.sort
+      end
+    end
+
+    describe "#points" do
+      it "should be number of points equal to REPLICAS * buckets.size " do
+        subject.points.size.should == subject.buckets.size * Hashring::REPLICAS
+      end
+    end
+
+    describe "#bucket_for" do
+      it "returns bucket for value" do
+        buckets.include?(subject.bucket_for('test')).should be_true
+      end
+    end
+
+    describe "#remove_bucket" do
+      it "removes the bucket from buckets array" do
+        subject.remove_bucket('server1')
+        subject.buckets.size.should == 1
+        subject.buckets.first.should == 'server2'
+      end
+
+      it "removes node from ring" do
+        subject.remove_bucket('server1')
+        subject.nodes.size.should == 1
+        subject.buckets.first.should == 'server2'
+      end
+    end
+
+    describe "#add_bucket" do
+      it "adds new bucket to buckets array" do
+        subject.add_bucket('blah')
+        subject.buckets.size.should == 3
+        subject.buckets.sort.first.should == 'blah'
+      end
+
+      it "adds node to ring" do
+        subject.add_bucket('blah')
+        subject.nodes.size.should == 3
+        subject.nodes.sort.first.should == 'blah'
+      end
+    end
+  end
+end

data/spec/integration_helper.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'net/http'
+require 'descriptive_statistics'
+require 'benchmark'
+ENV['GAME_ENV'] = 'test'
+require_relative '../lib/game_machine'
+require_relative '../lib/game_machine/clients/test_client'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    GameMachine::Application.initialize!('default',true)
+    GameMachine::Application.load_game_data
+    GameMachine::AuthHandlers::Base.instance
+    GameMachine::Application.start_actor_system
+    GameMachine::Application.start_core_systems
+    GameMachine::Application.start_handlers
+    GameMachine::Application.start_game_systems
+    GameMachine::Application.load_games
+    GameMachine::Application.start_endpoints
+    puts "before suite"
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:each) do
+  end
+
+  config.after(:suite) do
+    puts "after suite"
+    GameMachine::Application.stop
+  end
+end
+
+CHARS = [*('a'..'z'),*('0'..'9')].flatten
+STR = Array.new(100) {|i| CHARS.sample}.join
+STR2 = Array.new(1000) {|i| CHARS.sample}.join
+
+def player
+  player = MessageLib::Player.new
+  player.set_id(rand(5000).to_s)
+  player.set_name(STR.to_java_string)
+  player.set_authtoken('authorized')
+end
+
+def large_player
+  player = MessageLib::Player.new
+  player.set_id(rand(5000).to_s)
+  player.set_name(STR2.to_java_string)
+  player.set_authtoken('authorized')
+end
+
+def static_entity
+  entity = MessageLib::Entity.new
+  entity.set_id('1')
+  entity.player = player
+  echo_test = EchoTest.new.set_message('testing')
+  entity.set_echo_test(echo_test)
+  entity
+end
+
+def entity
+  entity = MessageLib::Entity.new
+  entity.set_id(rand(5000).to_s)
+  entity.player = player
+  echo_test = EchoTest.new.set_message('testing')
+  entity.set_echo_test(echo_test)
+  entity
+end
+
+def large_entity
+  entity = MessageLib::Entity.new
+  entity.set_id(rand(5000).to_s)
+  entity.set_player(large_player)
+  echo_test = EchoTest.new.set_message('testing')
+  entity.set_echo_test(echo_test)
+  entity
+end
+
+def client_message
+  client_message = ClientMessage.new
+  client_message.add_entity(entity)
+  client_message.set_player(player)
+  client_message
+end
+
+def static_client_message
+  client_message = ClientMessage.new
+  client_message.add_entity(static_entity)
+  client_message.set_player(player)
+  client_message
+end
+
+def large_client_message
+  client_message = ClientMessage.new
+  10.times do
+    client_message.add_entity(entity)
+  end
+  client_message.set_player(player)
+  client_message
+end
+
+def measure(num_threads,loops, pre=nil, post=nil,&blk)
+  threads = []
+  num_threads.times do |thread_id|
+    threads << Thread.new do
+      results = []
+      pre.call if pre
+      loops.times do |i|
+        results << Benchmark.realtime do
+          blk.call
+        end
+      end
+      post.call if post
+      puts "Number = #{results.number} Average #{results.mean} Standard deviation #{results.standard_deviation}"
+    end
+  end
+  threads.map(&:join)
+end
+

data/spec/java_grid_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+module GameMachine
+  describe JavaLib::Grid do
+
+    
+    subject do
+      JavaLib::Grid.new(100,25)
+    end
+
+    describe "#set" do
+      it "returns true when value is set" do
+        expect(subject.set('blah',0,0,0,'player')).to be_true
+      end
+
+      it "creates a grid point in correct cell" do
+        subject.set('blah',0,0,0,'player')
+        point = subject.grid_values_in_cell(0).first
+        expect(point.x).to eq(0)
+        expect(point.y).to eq(0)
+      end
+    end
+
+    describe "#get" do
+      it "Returns the values for the given id" do
+        subject.set('blah',0,0,3,'player')
+        grid_value = subject.get('blah')
+
+        expect(grid_value.id).to eq('blah')
+        expect(grid_value.cell).to eq(0)
+        expect(grid_value.x).to eq(0)
+        expect(grid_value.y).to eq(0)
+        expect(grid_value.z).to eq(3)
+      end
+    end
+
+    describe "#remove" do
+      it "Removes the cell entry" do
+        subject.set('blah',0,0,3,'player')
+        subject.remove('blah')
+        points = subject.grid_values_in_cell(0)
+        expect(points).to be_empty
+        expect(subject.neighbors(0,0,25,nil)).to be_empty
+      end
+    end
+
+    describe "#cells_within_radius" do
+      it "returns the correct cells" do
+        subject.cellsWithinRadius(0,0,50)
+      end
+    end
+
+    describe "#neighbors" do
+
+      it "returns empty array when no neighbors found" do
+        expect(subject.neighbors(0,0,25,nil)).to be_empty
+      end
+
+      it "returns all objects within given radius of cell" do
+        subject.set('blah',0,0,0,'player')
+        points = subject.neighbors(0,0,25,nil)
+        expect(points.first.cell).to eq(0)
+      end
+
+      it "returns entities of the correct type" do
+        subject.set('blah',0,0,0,'player')
+        points = subject.neighbors(0,0,25,'player')
+        expect(points.first.cell).to eq(0)
+
+      end
+
+      it "does not return cells out of range" do
+        subject.set('blah',0,0,0,'player')
+        expect(subject.neighbors(50,50,25,nil)).to be_empty
+      end
+
+      it "returns multiple points in the same cell" do
+        subject.set('blah',3,3,0,'player')
+        subject.set('blah2',4,4,0,'player')
+        points = subject.neighbors(0,0,25,nil).to_a
+        expect(points.last.x).to eq(3)
+        expect(points.first.x).to eq(4)
+      end
+
+      context "caller id is passed" do
+
+      end
+    end
+  end
+end