rmuh 0.2.5 → 0.2.6

data/spec/unit/rmuh/rpt/log/parsers/unitedoperationslog_spec.rb

@@ -65,12 +65,12 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
 
     it 'should not include chat by default' do
       u = uolog.instance_variable_get(:@include_chat)
-      expect(u).to be_false
+      expect(u).to be_falsey
     end
 
     it 'should convert to zulu by default' do
       u = uolog.instance_variable_get(:@to_zulu)
-      expect(u).to be_true
+      expect(u).to be_truthy
     end
 
     it 'should use the UO timezone by default' do
@@ -193,7 +193,7 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     it 'should set date as today if line (0400-2359) and now same range ' do
       tz = uolog.instance_variable_get(:@timezone)
       l = yday_line.dup
-      uolog.stub(:date_of_line_based_on_now) { tz.now }
+      allow(uolog).to receive(:date_of_line_based_on_now).and_return(tz.now)
       uolog.send(:when_am_i!, l)
       expect(l[:year]).to eql tz.now.year
       expect(l[:month]).to eql tz.now.month
@@ -204,7 +204,8 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
       d = RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY
       tz = uolog.instance_variable_get(:@timezone)
       l = yday_line.dup
-      uolog.stub(:date_of_line_based_on_now) { tz.now - d }
+      allow(uolog).to receive(:date_of_line_based_on_now)
+        .and_return(tz.now - d)
       uolog.send(:when_am_i!, l)
       expect(l[:year]).to eql((tz.now - d).year)
       expect(l[:month]).to eql((tz.now - d).month)
@@ -237,22 +238,39 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     it 'should call where_am_i! and set the year/month/day' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      expect(x.key?(:year)).to be_true
-      expect(x.key?(:month)).to be_true
-      expect(x.key?(:day)).to be_true
+      expect(x.key?(:year)).to be_truthy
+      expect(x.key?(:month)).to be_truthy
+      expect(x.key?(:day)).to be_truthy
     end
 
     it 'sould call zulu! and set the time to zulu' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      expect(x.key?(:iso8601)).to be_true
-      expect(x.key?(:dtg)).to be_true
+      expect(x.key?(:iso8601)).to be_truthy
+      expect(x.key?(:dtg)).to be_truthy
     end
 
     it 'should call add_guid! and add the event_guid' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
+    end
+
+    context 'when a user join event' do
+      it 'should call strip_port!' do
+        l = { hour: 4, min: 0, sec: 0, type: :connect, net: '127.0.0.1:443' }
+        x = uolog.send(:line_modifiers, l)
+        expect(x.key?(:ipaddr)).to be_truthy
+        expect(x.key?(:net)).to be_falsey
+      end
+    end
+
+    context 'when not a user joint event' do
+      it 'should not call strip_port!' do
+        l = { hour: 4, min: 0, sec: 0, type: :x, net: '127.0.0.1:443' }
+        x = uolog.send(:line_modifiers, l)
+        expect(x.key?(:net)).to be_truthy
+      end
     end
   end
 
@@ -307,23 +325,23 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new
       expect(
         u.send(:regex_matches, StringIO.new(chat_line)).empty?
-      ).to be_true
+      ).to be_truthy
     end
 
     it 'should compact the Array' do
       l = StringIO.new("Something1\nSomething2\n")
       x = uolog.send(:regex_matches, l)
-      expect(x.include?(nil)).to be_false
+      expect(x.include?(nil)).to be_falsey
     end
 
     it 'should call #line_modifiers' do
       x = uolog.send(:regex_matches, StringIO.new(guid_line))
-      expect(x[0].key?(:year)).to be_true
-      expect(x[0].key?(:month)).to be_true
-      expect(x[0].key?(:day)).to be_true
-      expect(x[0].key?(:iso8601)).to be_true
-      expect(x[0].key?(:dtg)).to be_true
-      expect(x[0].key?(:event_guid)).to be_true
+      expect(x[0].key?(:year)).to be_truthy
+      expect(x[0].key?(:month)).to be_truthy
+      expect(x[0].key?(:day)).to be_truthy
+      expect(x[0].key?(:iso8601)).to be_truthy
+      expect(x[0].key?(:dtg)).to be_truthy
+      expect(x[0].key?(:event_guid)).to be_truthy
     end
   end
 
@@ -379,13 +397,13 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
 
     it 'should call #regex_matches' do
       x = uolog.parse(StringIO.new(guid_line))
-      expect(x[0].key?(:type)).to be_true
-      expect(x[0].key?(:year)).to be_true
-      expect(x[0].key?(:month)).to be_true
-      expect(x[0].key?(:day)).to be_true
-      expect(x[0].key?(:iso8601)).to be_true
-      expect(x[0].key?(:dtg)).to be_true
-      expect(x[0].key?(:event_guid)).to be_true
+      expect(x[0].key?(:type)).to be_truthy
+      expect(x[0].key?(:year)).to be_truthy
+      expect(x[0].key?(:month)).to be_truthy
+      expect(x[0].key?(:day)).to be_truthy
+      expect(x[0].key?(:iso8601)).to be_truthy
+      expect(x[0].key?(:dtg)).to be_truthy
+      expect(x[0].key?(:event_guid)).to be_truthy
     end
   end
 end

data/spec/unit/rmuh/rpt/log/parsers/unitedoperationsrpt_spec.rb

@@ -140,7 +140,7 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     end
 
     it 'should set @to_zulu to true if nothing provided' do
-      expect(uorpt.instance_variable_get(:@to_zulu)).to be_true
+      expect(uorpt.instance_variable_get(:@to_zulu)).to be_truthy
     end
 
     it 'should set @timezone to America/Los_Angeles if nothing provided' do
@@ -243,7 +243,7 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     it 'should return an Array of hashes if a line matches' do
       x = uorpt.parse(loglines)
       expect(x).to be_an_instance_of Array
-      expect(x.empty?).to be_false
+      expect(x.empty?).to be_falsey
       x.each { |y| expect(y).to be_an_instance_of Hash }
     end
   end

data/spec/unit/rmuh/rpt/log/util/unitedoperations_spec.rb

@@ -9,7 +9,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     @uo_util.extend(RMuh::RPT::Log::Util::UnitedOperations)
     @mi = Regexp.new(
       '(?<year>\d+)/(?<month>\d+)/(?<day>\d+)'\
-      '\s(?<hour>\d+):(?<min>\d+):(?<sec>\d+)'
+      '\s(?<hour>\d+):(?<min>\d+):(?<sec>\d+)\s(?<player_num>\d+)'
     )
     @mf = Regexp.new(
       '(?<server_time>[0-9.]+)\s(?<damage>[0-9.]+)\s(?<distance>[0-9.]+)'
@@ -44,7 +44,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       t.strftime('%Y-%m-%dT%H:%M:%SZ')
     end
     let(:zulued) do
-      ml = @uo_util.m_to_h(@mi.match('2013/12/31 16:00:00'))
+      ml = @uo_util.m_to_h(@mi.match('2013/12/31 16:00:00 0'))
       @uo_util.zulu!(ml, uo_tz)
     end
 
@@ -57,7 +57,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should return a Hash' do
-      ml = @uo_util.m_to_h(@mi.match('2013/12/31 16:00:00'))
+      ml = @uo_util.m_to_h(@mi.match('2013/12/31 16:00:00 0'))
       mr = @uo_util.zulu!(ml, uo_tz)
       expect(mr).to be_an_instance_of Hash
     end
@@ -165,42 +165,42 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     it 'should properly set the :event_guid for killed' do
       x = @uo_util.add_guid!(spec_killed_line)
       y = spec_guid_reference_implementation(spec_killed_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for died' do
       x = @uo_util.add_guid!(spec_died_line)
       y = spec_guid_reference_implementation(spec_died_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(y[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for wounded' do
       x = @uo_util.add_guid!(spec_wounded_line)
       y = spec_guid_reference_implementation(spec_wounded_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for announcements' do
       x = @uo_util.add_guid!(spec_announcement_line)
       y = spec_guid_reference_implementation(spec_announcement_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for beguid' do
       x = @uo_util.add_guid!(spec_beguid_line)
       y = spec_guid_reference_implementation(spec_beguid_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for chat' do
       x = @uo_util.add_guid!(spec_chat_line)
       y = spec_guid_reference_implementation(spec_chat_line)
-      expect(x.key?(:event_guid)).to be_true
+      expect(x.key?(:event_guid)).to be_truthy
       expect(x[:event_guid]).to eql y[:event_guid]
     end
   end
@@ -270,8 +270,8 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should convert the correct values to Fixnum' do
-      md = @mi.match('2014/02/09 14:44:44')
-      %w( year month day hour min sec ).each do |m|
+      md = @mi.match('2014/02/09 14:44:44 0')
+      %w( year month day hour min sec player_num ).each do |m|
         x = @uo_util.__line_modifiers(md, m)
         expect(x).to be_an_instance_of Fixnum
         expect(x).to eql md[m].to_i
@@ -315,7 +315,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should properly convert the correct values to int' do
-      md = @mi.match('2014/02/09 14:44:44')
+      md = @mi.match('2014/02/09 14:44:44 0')
       h = @uo_util.m_to_h(md)
       [:year, :month, :day, :hour, :min, :sec].each do |m|
         expect(h[m]).to be_an_instance_of Fixnum
@@ -346,7 +346,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       md = @ma.match('None."')
       h = @uo_util.m_to_h(md)
       expect(h[:nearby_players]).to be_an_instance_of Array
-      expect(h[:nearby_players].empty?).to be_true
+      expect(h[:nearby_players].empty?).to be_truthy
     end
   end
 

data/spec/unit/rmuh/rpt/log/util/unitedoperationslog_spec.rb

@@ -6,56 +6,53 @@ describe RMuh::RPT::Log::Util::UnitedOperationsLog do
     @uo_util.extend(RMuh::RPT::Log::Util::UnitedOperationsLog)
   end
 
-  context '::ONE_DAY' do
-    it 'should be an instance of Fixnum' do
-      expect(
-        RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY
-      ).to be_an_instance_of Fixnum
-    end
+  describe '::ONE_DAY' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY }
 
-    it 'should be 24 hours in seconds' do
-      expect(RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY).to eql 86_400
-    end
+    it { should be_an_instance_of Fixnum }
+
+    it { should eql 86_400 }
   end
 
-  context '::TIME' do
-    it 'should be an instance of String' do
-      expect(
-        RMuh::RPT::Log::Util::UnitedOperationsLog::TIME
-      ).to be_an_instance_of String
-    end
+  describe '::TIME_SHORT' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::TIME_SHORT }
+
+    it { should be_an_instance_of String }
   end
 
-  context '::GUID' do
-    it 'should be an instance of Regexp' do
-      expect(
-        RMuh::RPT::Log::Util::UnitedOperationsLog::GUID
-      ).to be_an_instance_of Regexp
-    end
+  describe '::TIME' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::TIME }
+
+    it { should be_an_instance_of String }
+  end
+
+  describe '::GUID' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::GUID }
+
+    it { should be_an_instance_of Regexp }
 
     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 = subject.match(l)
       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'
+      expect(m['player_num']).to eql '0'
     end
   end
 
-  context '::CHAT' do
-    it 'should be an instance of Regexp' do
-      expect(
-        RMuh::RPT::Log::Util::UnitedOperationsLog::CHAT
-      ).to be_an_instance_of Regexp
-    end
+  describe '::CHAT' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::CHAT }
+
+    it { should be_an_instance_of Regexp }
 
     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 = subject.match(l)
       expect(m['hour']).to eql '5'
       expect(m['min']).to eql '48'
       expect(m['sec']).to eql '01'
@@ -64,4 +61,37 @@ describe RMuh::RPT::Log::Util::UnitedOperationsLog do
       expect(m['message']).to eql 'Admin back'
     end
   end
+
+  describe '::JOINED' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::JOINED }
+
+    it { should be_an_instance_of Regexp }
+
+    it 'should match an example line' do
+      l = ' 4:01:09 BattlEye Server: Player #0 Delta38 ' \
+          '(127.0.0.1:65007) connected'
+      m = subject.match(l)
+      expect(m['hour']).to eql '4'
+      expect(m['min']).to eql '01'
+      expect(m['sec']).to eql '09'
+      expect(m['player']).to eql 'Delta38'
+      expect(m['player_num']).to eql '0'
+      expect(m['net']).to eql  '127.0.0.1:65007'
+    end
+  end
+
+  describe '::LEFT' do
+    subject { RMuh::RPT::Log::Util::UnitedOperationsLog::LEFT }
+
+    it { should be_an_instance_of Regexp }
+
+    it 'should match an example line' do
+      l = ' 5:05:53 Player MPWR disconnected.'
+      m = subject.match(l)
+      expect(m['hour']).to eql '5'
+      expect(m['min']).to eql '05'
+      expect(m['sec']).to eql '53'
+      expect(m['player']).to eq 'MPWR'
+    end
+  end
 end

data/spec/unit/rmuh/rpt_spec.rb

@@ -3,31 +3,31 @@
 describe RMuh do
   context '::VERSION_MAJ' do
     it 'should have a major version that is an integer' do
-      expect(RMuh::VERSION_MAJ.is_a?(Integer)).to be_true
+      expect(RMuh::VERSION_MAJ.is_a?(Integer)).to be_truthy
     end
 
     it 'should have a major version that is a positive number' do
-      expect(RMuh::VERSION_MAJ > -1).to be_true
+      expect(RMuh::VERSION_MAJ > -1).to be_truthy
     end
   end
 
   context '::VERSION_MIN' do
     it 'should have a minor version that is an integer' do
-      expect(RMuh::VERSION_MIN.is_a?(Integer)).to be_true
+      expect(RMuh::VERSION_MIN.is_a?(Integer)).to be_truthy
     end
 
     it 'should have a minor version that is a positive integer' do
-      expect(RMuh::VERSION_MIN > -1).to be_true
+      expect(RMuh::VERSION_MIN > -1).to be_truthy
     end
   end
 
   context '::VERSION_REV' do
     it 'should have a revision number that is an integer' do
-      expect(RMuh::VERSION_REV.is_a?(Integer)).to be_true
+      expect(RMuh::VERSION_REV.is_a?(Integer)).to be_truthy
     end
 
     it 'should have a revision number that is a positive integer' do
-      expect(RMuh::VERSION_REV > -1).to be_true
+      expect(RMuh::VERSION_REV > -1).to be_truthy
     end
   end
 

data/spec/unit/rmuh/serverstats/base.rb

@@ -37,15 +37,15 @@ shared_examples 'RMuh::ServerStats::Base' do
     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.key?(:port)).to be_truthy
       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
+      expect(h.key?(:auto_cache)).to be_truthy
+      expect(h[:auto_cache]).to be_truthy
     end
 
     it 'should return nil' do
@@ -122,7 +122,8 @@ shared_examples 'RMuh::ServerStats::Base' do
 
   context '#sync' do
     before do
-      GamespyQuery::Socket.any_instance.stub(:sync).and_return(one: 1)
+      allow_any_instance_of(GamespyQuery::Socket).to receive(:sync)
+        .and_return(one: 1)
     end
     let(:b) { RMuh::ServerStats::Base.new(host: '127.0.0.1') }
 
@@ -149,7 +150,7 @@ shared_examples 'RMuh::ServerStats::Base' do
 
     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')
+      allow(n).to receive(:sync).and_return(one: 'two')
       expect(n.send(:remote_stats)).to eql(one: 'two')
     end
   end
@@ -158,8 +159,8 @@ shared_examples 'RMuh::ServerStats::Base' do
     before(:each) do
       @b = RMuh::ServerStats::Base.new(host: '127.0.0.1')
       @bf = RMuh::ServerStats::Base.new(host: '127.0.0.1', cache: false)
-      @b.stub(:sync).and_return(one: 'two')
-      @bf.stub(:sync).and_return(one: 'two')
+      allow(@b).to receive(:sync).and_return(one: 'two')
+      allow(@bf).to receive(:sync).and_return(one: 'two')
     end
 
     it 'should take no args' do
@@ -181,8 +182,8 @@ shared_examples 'RMuh::ServerStats::Base' do
     before(:each) do
       @b = RMuh::ServerStats::Base.new(host: '127.0.0.1')
       @bf = RMuh::ServerStats::Base.new(host: '127.0.0.1', cache: false)
-      @b.stub(:sync).and_return(one: 'two')
-      @bf.stub(:sync).and_return(one: 'two')
+      allow(@b).to receive(:sync).and_return(one: 'two')
+      allow(@bf).to receive(:sync).and_return(one: 'two')
       @b.update_cache
     end