rmuh 0.2.1 → 0.2.2

data/spec/rmuh_rpt_log_util_unitedoperationslog_spec.rb

@@ -11,56 +11,60 @@ describe RMuh::RPT::Log::Util::UnitedOperationsLog do
 
   context '::ONE_DAY' do
     it 'should be an instance of Fixnum' do
-      RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY
-        .should be_an_instance_of Fixnum
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY
+      ).to be_an_instance_of Fixnum
     end
 
     it 'should be 24 hours in seconds' do
-      RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY.should eql 86_400
+      expect(RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY).to eql 86_400
     end
   end
 
   context '::TIME' do
     it 'should be an instance of String' do
-      RMuh::RPT::Log::Util::UnitedOperationsLog::TIME
-        .should be_an_instance_of String
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsLog::TIME
+      ).to be_an_instance_of String
     end
   end
 
   context '::GUID' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsLog::GUID
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsLog::GUID
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
       l = ' 4:01:02 BattlEye Server: Verified GUID ' \
           '(04de012b0f882b9ff2e43564c8c09361) of player #0 nametag47'
       m = RMuh::RPT::Log::Util::UnitedOperationsLog::GUID.match(l)
-      m.should_not be_nil
-      m['hour'].should eql '4'
-      m['min'].should eql '01'
-      m['sec'].should eql '02'
-      m['player_beguid'].should eql '04de012b0f882b9ff2e43564c8c09361'
-      m['player'].should eql 'nametag47'
+      expect(m).to_not be_nil
+      expect(m['hour']).to eql '4'
+      expect(m['min']).to eql '01'
+      expect(m['sec']).to eql '02'
+      expect(m['player_beguid']).to eql '04de012b0f882b9ff2e43564c8c09361'
+      expect(m['player']).to eql 'nametag47'
     end
   end
 
   context '::CHAT' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsLog::CHAT
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsLog::CHAT
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
       l = ' 5:48:01 BattlEye Server: (Side) Xcenocide: Admin back'
       m = RMuh::RPT::Log::Util::UnitedOperationsLog::CHAT.match(l)
-      m['hour'].should eql '5'
-      m['min'].should eql '48'
-      m['sec'].should eql '01'
-      m['channel'].should eql 'Side'
-      m['player'].should eql 'Xcenocide'
-      m['message'].should eql 'Admin back'
+      expect(m['hour']).to eql '5'
+      expect(m['min']).to eql '48'
+      expect(m['sec']).to eql '01'
+      expect(m['channel']).to eql 'Side'
+      expect(m['player']).to eql 'Xcenocide'
+      expect(m['message']).to eql 'Admin back'
     end
   end
 end

data/spec/rmuh_rpt_log_util_unitedoperationsrpt_spec.rb

@@ -6,15 +6,17 @@ require File.join(repo_root, 'lib/rmuh/rpt/log/util/unitedoperationsrpt')
 describe RMuh::RPT::Log::Util::UnitedOperationsRPT do
   context '::DTR' do
     it 'should be an instance of String' do
-      RMuh::RPT::Log::Util::UnitedOperationsRPT::DTR
-        .should be_an_instance_of String
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsRPT::DTR
+      ).to be_an_instance_of String
     end
   end
 
   context '::KILLED' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsRPT::KILLED
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsRPT::KILLED
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
@@ -24,31 +26,32 @@ describe RMuh::RPT::Log::Util::UnitedOperationsRPT do
           '[6498.62,6916.71,0.0204163] (GRID 0649806916). Distance between: ' \
           '71.1653 meters. Near players (100m): None."'
       m = RMuh::RPT::Log::Util::UnitedOperationsRPT::KILLED.match(l)
-      m.should_not be_nil
-      m['year'].should eql '2014'
-      m['month'].should eql '02'
-      m['day'].should eql '16'
-      m['hour'].should eql '4'
-      m['min'].should eql '11'
-      m['sec'].should eql '42'
-      m['server_time'].should eql '69.85'
-      m['victim'].should eql 'Olli'
-      m['victim_team'].should eql 'CIV'
-      m['offender'].should eql 'Yevgeniy Nikolayev'
-      m['offender_team'].should eql 'EAST'
-      m['victim_position'].should eql '6553.55,6961.92,0.0015564'
-      m['victim_grid'].should eql '0655306961'
-      m['offender_position'].should eql '6498.62,6916.71,0.0204163'
-      m['offender_grid'].should eql '0649806916'
-      m['distance'].should eql '71.1653'
-      m['nearby_players'].should eql 'None.'
+      expect(m).to_not be_nil
+      expect(m['year']).to eql '2014'
+      expect(m['month']).to eql '02'
+      expect(m['day']).to eql '16'
+      expect(m['hour']).to eql '4'
+      expect(m['min']).to eql '11'
+      expect(m['sec']).to eql '42'
+      expect(m['server_time']).to eql '69.85'
+      expect(m['victim']).to eql 'Olli'
+      expect(m['victim_team']).to eql 'CIV'
+      expect(m['offender']).to eql 'Yevgeniy Nikolayev'
+      expect(m['offender_team']).to eql 'EAST'
+      expect(m['victim_position']).to eql '6553.55,6961.92,0.0015564'
+      expect(m['victim_grid']).to eql '0655306961'
+      expect(m['offender_position']).to eql '6498.62,6916.71,0.0204163'
+      expect(m['offender_grid']).to eql '0649806916'
+      expect(m['distance']).to eql '71.1653'
+      expect(m['nearby_players']).to eql 'None.'
     end
   end
 
   context '::DIED' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsRPT::DIED
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsRPT::DIED
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
@@ -56,67 +59,69 @@ describe RMuh::RPT::Log::Util::UnitedOperationsRPT do
           '[4602.18,7490.26,2.2435] (GRID 0460207490). Near players (100m): ' \
           '["Olli","nametag47","Villanyi"]"'
       m = RMuh::RPT::Log::Util::UnitedOperationsRPT::DIED.match(l)
-      m.should_not be_nil
-      m['year'].should eql '2014'
-      m['month'].should eql '02'
-      m['day'].should eql '16'
-      m['hour'].should eql '5'
-      m['min'].should eql '15'
-      m['sec'].should eql '06'
-      m['server_time'].should eql '3683.58'
-      m['victim'].should eql 'Appe96'
-      m['victim_position'].should eql '4602.18,7490.26,2.2435'
-      m['victim_grid'].should eql '0460207490'
-      m['nearby_players'].should eql '["Olli","nametag47","Villanyi"]'
+      expect(m).to_not be_nil
+      expect(m['year']).to eql '2014'
+      expect(m['month']).to eql '02'
+      expect(m['day']).to eql '16'
+      expect(m['hour']).to eql '5'
+      expect(m['min']).to eql '15'
+      expect(m['sec']).to eql '06'
+      expect(m['server_time']).to eql '3683.58'
+      expect(m['victim']).to eql 'Appe96'
+      expect(m['victim_position']).to eql '4602.18,7490.26,2.2435'
+      expect(m['victim_grid']).to eql '0460207490'
+      expect(m['nearby_players']).to eql '["Olli","nametag47","Villanyi"]'
     end
   end
 
   context '::WOUNDED' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsRPT::WOUNDED
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsRPT::WOUNDED
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
       l = '2014/02/16,  5:22:55 "4152.41 seconds: Sherminator (CIV) has ' \
           'been team wounded by Xcenocide (WEST) for 1.50828 damage."'
       m = RMuh::RPT::Log::Util::UnitedOperationsRPT::WOUNDED.match(l)
-      m.should_not be_nil
-      m['year'].should eql '2014'
-      m['month'].should eql '02'
-      m['day'].should eql '16'
-      m['hour'].should eql '5'
-      m['min'].should eql '22'
-      m['sec'].should eql '55'
-      m['server_time'].should eql '4152.41'
-      m['victim'].should eql 'Sherminator'
-      m['victim_team'].should eql 'CIV'
-      m['offender'].should eql 'Xcenocide'
-      m['offender_team'].should eql 'WEST'
-      m['damage'].should eql '1.50828'
+      expect(m).to_not be_nil
+      expect(m['year']).to eql '2014'
+      expect(m['month']).to eql '02'
+      expect(m['day']).to eql '16'
+      expect(m['hour']).to eql '5'
+      expect(m['min']).to eql '22'
+      expect(m['sec']).to eql '55'
+      expect(m['server_time']).to eql '4152.41'
+      expect(m['victim']).to eql 'Sherminator'
+      expect(m['victim_team']).to eql 'CIV'
+      expect(m['offender']).to eql 'Xcenocide'
+      expect(m['offender_team']).to eql 'WEST'
+      expect(m['damage']).to eql '1.50828'
     end
   end
 
   context '::ANNOUNCEMENT' do
     it 'should be an instance of Regexp' do
-      RMuh::RPT::Log::Util::UnitedOperationsRPT::ANNOUNCEMENT
-        .should be_an_instance_of Regexp
+      expect(
+        RMuh::RPT::Log::Util::UnitedOperationsRPT::ANNOUNCEMENT
+      ).to be_an_instance_of Regexp
     end
 
     it 'should match an example line' do
       l = '2014/02/16,  4:13:10 "############################# Start ' \
           'CO08_Escape_Chernarus_V1 #############################"'
       m = RMuh::RPT::Log::Util::UnitedOperationsRPT::ANNOUNCEMENT.match(l)
-      m.should_not be_nil
-      m['year'].should eql '2014'
-      m['month'].should eql '02'
-      m['day'].should eql '16'
-      m['hour'].should eql '4'
-      m['min'].should eql '13'
-      m['sec'].should eql '10'
-      m['head'].should eql '#############################'
-      m['message'].should eql 'Start CO08_Escape_Chernarus_V1'
-      m['tail'].should eql '#############################'
+      expect(m).to_not be_nil
+      expect(m['year']).to eql '2014'
+      expect(m['month']).to eql '02'
+      expect(m['day']).to eql '16'
+      expect(m['hour']).to eql '4'
+      expect(m['min']).to eql '13'
+      expect(m['sec']).to eql '10'
+      expect(m['head']).to eql '#############################'
+      expect(m['message']).to eql 'Start CO08_Escape_Chernarus_V1'
+      expect(m['tail']).to eql '#############################'
     end
   end
 end

data/spec/rmuh_rpt_spec.rb

@@ -5,41 +5,41 @@ require File.join(File.expand_path('../..', __FILE__), 'lib/rmuh/version')
 describe RMuh do
   context '::VERSION_MAJ' do
     it 'should have a major version that is an integer' do
-      RMuh::VERSION_MAJ.is_a?(Integer).should be_true
+      expect(RMuh::VERSION_MAJ.is_a?(Integer)).to be_true
     end
 
     it 'should have a major version that is a positive number' do
-      (RMuh::VERSION_MAJ > -1).should be_true
+      expect(RMuh::VERSION_MAJ > -1).to be_true
     end
   end
 
   context '::VERSION_MIN' do
     it 'should have a minor version that is an integer' do
-      RMuh::VERSION_MIN.is_a?(Integer).should be_true
+      expect(RMuh::VERSION_MIN.is_a?(Integer)).to be_true
     end
 
     it 'should have a minor version that is a positive integer' do
-      (RMuh::VERSION_MIN > -1).should be_true
+      expect(RMuh::VERSION_MIN > -1).to be_true
     end
   end
 
   context '::VERSION_REV' do
     it 'should have a revision number that is an integer' do
-      RMuh::VERSION_REV.is_a?(Integer).should be_true
+      expect(RMuh::VERSION_REV.is_a?(Integer)).to be_true
     end
 
     it 'should have a revision number that is a positive integer' do
-      (RMuh::VERSION_REV > -1).should be_true
+      expect(RMuh::VERSION_REV > -1).to be_true
     end
   end
 
   context '::VERSION' do
     it 'should have a version that is a string' do
-      RMuh::VERSION.should be_an_instance_of String
+      expect(RMuh::VERSION).to be_an_instance_of String
     end
 
     it 'should match the following format N.N.N' do
-      /\A(?:\d+?\.){2}\d+?/.match(RMuh::VERSION).should_not be_nil
+      expect(/\A(?:\d+?\.){2}\d+?/.match(RMuh::VERSION)).to_not be_nil
     end
   end
 end

data/spec/rmuh_serverstats_base_spec.rb

@@ -10,15 +10,17 @@ describe RMuh::ServerStats::Base do
     let(:port) { RMuh::ServerStats::Base::DEFAULT_PORT }
 
     it 'should be an instance of Fixnum' do
-      port.should be_an_instance_of Fixnum
+      expect(port).to be_an_instance_of Fixnum
     end
 
     it 'should be the default ArmA 2 port' do
-      port.should eql 2_302
+      expect(port).to eql 2_302
     end
   end
 
   context '::validate_opts' do
+    let(:srv_hash) { { host: '127.0.0.1' } }
+
     it 'should take no more than one arg' do
       expect do
         RMuh::ServerStats::Base.validate_opts(nil, nil)
@@ -37,9 +39,23 @@ describe RMuh::ServerStats::Base do
       end.to raise_error ArgumentError
     end
 
+    it 'should set the default port if not provided' do
+      h = srv_hash.dup
+      RMuh::ServerStats::Base.validate_opts(h)
+      expect(h.key?(:port)).to be_true
+      expect(h[:port]).to eql RMuh::ServerStats::Base::DEFAULT_PORT
+    end
+
+    it 'should set the auto_cache key to true if not provided' do
+      h = srv_hash.dup
+      RMuh::ServerStats::Base.validate_opts(h)
+      expect(h.key?(:auto_cache)).to be_true
+      expect(h[:auto_cache]).to be_true
+    end
+
     it 'should return nil' do
       x = RMuh::ServerStats::Base.validate_opts(host: '127.0.0.1')
-      x.should be_nil
+      expect(x).to be_nil
     end
   end
 
@@ -60,13 +76,13 @@ describe RMuh::ServerStats::Base do
 
     it 'should convert each key to an instance variable' do
       h = { one: 1, two: '2', three: :three }
-      b.instance_variable_get(:@one).should be_nil
-      b.instance_variable_get(:@two).should be_nil
-      b.instance_variable_get(:@three).should be_nil
+      expect(b.instance_variable_get(:@one)).to be_nil
+      expect(b.instance_variable_get(:@two)).to be_nil
+      expect(b.instance_variable_get(:@three)).to be_nil
       b.send(:opts_to_instance, h)
-      b.instance_variable_get(:@one).should eql h[:one]
-      b.instance_variable_get(:@two).should eql h[:two]
-      b.instance_variable_get(:@three).should eql h[:three]
+      expect(b.instance_variable_get(:@one)).to eql h[:one]
+      expect(b.instance_variable_get(:@two)).to eql h[:two]
+      expect(b.instance_variable_get(:@three)).to eql h[:three]
     end
   end
 
@@ -79,7 +95,7 @@ describe RMuh::ServerStats::Base do
 
     it 'should return an instance of itself if arg 1 is a Hash' do
       s = RMuh::ServerStats::Base.new(host: '127.0.0.1')
-      s.should be_an_instance_of RMuh::ServerStats::Base
+      expect(s).to be_an_instance_of RMuh::ServerStats::Base
     end
 
     it 'should require the host attribute' do
@@ -91,21 +107,21 @@ describe RMuh::ServerStats::Base do
     it 'should set an instance variable for each thing in Hash' do
       h = { host: '1.2.3.4', port: 2_303, cache: false }
       s = RMuh::ServerStats::Base.new(h)
-      s.instance_variable_get(:@host).should eql h[:host]
-      s.instance_variable_get(:@port).should eql h[:port]
-      s.instance_variable_get(:@cache).should eql h[:cache]
+      expect(s.instance_variable_get(:@host)).to eql h[:host]
+      expect(s.instance_variable_get(:@port)).to eql h[:port]
+      expect(s.instance_variable_get(:@cache)).to eql h[:cache]
     end
 
     it 'should create an instance of GamespyQuery::Socket' do
       s = RMuh::ServerStats::Base.new(host: '127.0.0.1')
       x = s.instance_variable_get(:@gsq)
-      x.should be_an_instance_of GamespyQuery::Socket
+      expect(x).to be_an_instance_of GamespyQuery::Socket
     end
 
     it 'should specify default values for @port and @cache' do
       s = RMuh::ServerStats::Base.new(host: '127.0.0.1')
-      s.instance_variable_get(:@cache).should be true
-      s.instance_variable_get(:@port).should eql 2_302
+      expect(s.instance_variable_get(:@cache)).to be true
+      expect(s.instance_variable_get(:@port)).to eql 2_302
     end
   end
 
@@ -120,7 +136,7 @@ describe RMuh::ServerStats::Base do
     end
 
     it 'should return a Hash' do
-      b.send(:sync).should be_an_instance_of Hash
+      expect(b.send(:sync)).to be_an_instance_of Hash
     end
   end
 
@@ -133,13 +149,13 @@ describe RMuh::ServerStats::Base do
 
     it 'should return the content of @servicestats if cache == true' do
       b.instance_variable_set(:@serverstats, one: 'two')
-      b.send(:remote_stats).should eql(one: 'two')
+      expect(b.send(:remote_stats)).to eql(one: 'two')
     end
 
     it 'should return the return value from the #sync method if cache true' do
       n = RMuh::ServerStats::Base.new(host: '127.0.0.1', cache: false)
       n.stub(:sync).and_return(one: 'two')
-      n.send(:remote_stats).should eql(one: 'two')
+      expect(n.send(:remote_stats)).to eql(one: 'two')
     end
   end
 
@@ -157,12 +173,12 @@ describe RMuh::ServerStats::Base do
 
     it 'should set the contents of @serverstats if caching' do
       @b.update_cache
-      @b.instance_variable_get(:@serverstats).should eql(one: 'two')
+      expect(@b.instance_variable_get(:@serverstats)).to eql(one: 'two')
     end
 
     it 'should not set the contents of @serverstats if no caching' do
       @bf.update_cache
-      @bf.instance_variable_get(:@serverstats).should be_nil
+      expect(@bf.instance_variable_get(:@serverstats)).to be_nil
     end
   end
 
@@ -180,11 +196,11 @@ describe RMuh::ServerStats::Base do
     end
 
     it 'should return the contents of @serverstats if caching enabled' do
-      @b.stats.should eql @b.instance_variable_get(:@serverstats)
+      expect(@b.stats).to eql @b.instance_variable_get(:@serverstats)
     end
 
     it 'should return the contents of sync if caching is disabled' do
-      @bf.stats.should eql(one: 'two')
+      expect(@bf.stats).to eql(one: 'two')
     end
   end
 end