ohloh_scm 4.0.4 → 5.0.0

data/spec/ohloh_scm/git/activity_spec.rb

@@ -9,7 +9,7 @@ describe 'Git::Activity' do
         git.activity.export(dir)
         entries = ['.', '..', '.gitignore', 'COPYING', 'Gemfile.lock', 'Godeps', 'README',
                    'helloworld.c', 'makefile', 'nested', 'ohloh_token']
-        Dir.entries(dir).sort.must_equal entries
+        assert_equal Dir.entries(dir).sort, entries
       end
     end
   end
@@ -17,16 +17,16 @@ describe 'Git::Activity' do
   it 'export must work the same for tag or commit_sha' do
     with_git_repository('git') do |git|
       tag_sha = 'f6e5a894ac4173f8f2a200f2c36df38a1e61121a'
-      commit_sha = `cd #{ git.scm.url } && git show #{ tag_sha }`.slice(/commit (.+)$/, 1)
+      commit_sha = `cd #{git.scm.url} && git show #{tag_sha}`.slice(/commit (.+)$/, 1)
 
       Dir.mktmpdir('oh_scm_tag_') do |tag_dir|
         git.activity.export(tag_dir, tag_sha)
 
         Dir.mktmpdir('oh_scm_commit_') do |commit_dir|
           git.activity.export(commit_dir, commit_sha)
-          `diff -rq #{ tag_dir } #{ commit_dir }`.must_be :empty?
-          Dir.entries(commit_dir).sort.must_equal ['.', '..', '.gitignore', 'helloworld.c',
-                                                   'makefile', 'ohloh_token']
+          assert_empty `diff -rq #{tag_dir} #{commit_dir}`
+          assert_equal Dir.entries(commit_dir).sort, ['.', '..', '.gitignore', 'helloworld.c',
+                                                      'makefile', 'ohloh_token']
         end
       end
     end
@@ -41,18 +41,18 @@ describe 'Git::Activity' do
   describe 'tags' do
     it 'scm test fixture must have dereferenced tags' do
       with_git_repository('git') do |git|
-        tag_shas = `cd #{git.scm.url} && git tag --format='%(objectname)' | sed 's/refs\\/tags\\///'`.split(/\n/)
+        tag_shas = `cd #{git.scm.url} && git tag --format='%(objectname)' | sed 's/refs\\/tags\\///'`.split("\n")
         assert(tag_shas.any? { |sha| !git.activity.commit_tokens.include?(sha) })
       end
     end
 
     it 'must return repository tags' do
       with_git_repository('git') do |git|
-        git.activity.tags.must_equal(
-          [['v1.0.0', 'b6e9220c3cabe53a4ed7f32952aeaeb8a822603d', Time.parse('2016-07-31T07:58:30+05:30')],
-           ['v1.1.0-lw', '2e9366dd7a786fdb35f211fff1c8ea05c51968b1', Time.parse('2006-06-11T11:34:17-07:00')],
-           ['v2.1.0', '1df547800dcd168e589bb9b26b4039bff3a7f7e4', Time.parse('2006-07-14T16:07:15-07:00')]]
-        )
+        assert_equal git.activity.tags,
+                     [['v1.0.0', 'b6e9220c3cabe53a4ed7f32952aeaeb8a822603d', Time.parse('2016-07-31T07:58:30+05:30')],
+                      ['v1.1.0-lw', '2e9366dd7a786fdb35f211fff1c8ea05c51968b1',
+                       Time.parse('2006-06-11T11:34:17-07:00')],
+                      ['v2.1.0', '1df547800dcd168e589bb9b26b4039bff3a7f7e4', Time.parse('2006-07-14T16:07:15-07:00')]]
       end
     end
 
@@ -65,14 +65,14 @@ describe 'Git::Activity' do
 
     it 'must be empty for repository with no tags' do
       with_git_repository('git_walk') do |git|
-        git.activity.tags.must_be :empty?
+        assert_empty git.activity.tags
       end
     end
 
     it 'must work for a tag named master' do
       with_git_repository('git_with_master_tag') do |git|
-        git.activity.tags.must_equal [['master', '4e95717ac8cff8cdb10d83398d3ac667a2cca341',
-                                       Time.parse('2018-02-01T12:56:48+0530')]]
+        assert_equal git.activity.tags, [['master', '4e95717ac8cff8cdb10d83398d3ac667a2cca341',
+                                          Time.parse('2018-02-01T12:56:48+0530')]]
       end
     end
   end
@@ -80,8 +80,8 @@ describe 'Git::Activity' do
   it 'must return correct head' do
     with_git_repository('git') do |git|
       assert git.status.exist?
-      git.activity.head_token.must_equal 'a2690f4471a0852723f0f0e95d97f7f1f3981639'
-      git.activity.head.token.must_equal 'a2690f4471a0852723f0f0e95d97f7f1f3981639'
+      assert_equal git.activity.head_token, 'a2690f4471a0852723f0f0e95d97f7f1f3981639'
+      assert_equal git.activity.head.token, 'a2690f4471a0852723f0f0e95d97f7f1f3981639'
       assert git.activity.head.diffs.any?
     end
   end
@@ -94,53 +94,53 @@ describe 'Git::Activity' do
 
   it 'commit_count' do
     with_git_repository('git') do |git|
-      git.activity.commit_count.must_equal 5
-      git.activity.commit_count(after: 'b6e9220c3cabe53a4ed7f32952aeaeb8a822603d').must_equal 3
-      git.activity.commit_count(after: '1df547800dcd168e589bb9b26b4039bff3a7f7e4').must_equal 1
+      assert_equal git.activity.commit_count, 5
+      assert_equal git.activity.commit_count(after: 'b6e9220c3cabe53a4ed7f32952aeaeb8a822603d'), 3
+      assert_equal git.activity.commit_count(after: '1df547800dcd168e589bb9b26b4039bff3a7f7e4'), 1
     end
   end
 
   it 'commit_tokens' do
     with_git_repository('git') do |git|
-      git.activity.commit_tokens.must_equal %w[089c527c61235bd0793c49109b5bd34d439848c6
-                                               b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
-                                               2e9366dd7a786fdb35f211fff1c8ea05c51968b1
-                                               1df547800dcd168e589bb9b26b4039bff3a7f7e4
-                                               a2690f4471a0852723f0f0e95d97f7f1f3981639]
+      assert_equal git.activity.commit_tokens, %w[089c527c61235bd0793c49109b5bd34d439848c6
+                                                  b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
+                                                  2e9366dd7a786fdb35f211fff1c8ea05c51968b1
+                                                  1df547800dcd168e589bb9b26b4039bff3a7f7e4
+                                                  a2690f4471a0852723f0f0e95d97f7f1f3981639]
 
-      git.activity.commit_tokens(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1')
-         .must_equal %w[1df547800dcd168e589bb9b26b4039bff3a7f7e4 a2690f4471a0852723f0f0e95d97f7f1f3981639]
+      assert_equal git.activity.commit_tokens(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1'),
+                   %w[1df547800dcd168e589bb9b26b4039bff3a7f7e4 a2690f4471a0852723f0f0e95d97f7f1f3981639]
 
-      git.activity.commit_tokens(after: 'a2690f4471a0852723f0f0e95d97f7f1f3981639').must_be :empty?
+      assert_empty git.activity.commit_tokens(after: 'a2690f4471a0852723f0f0e95d97f7f1f3981639')
     end
   end
 
   it 'commits' do
     with_git_repository('git') do |git|
-      git.activity.commits.collect(&:token).must_equal %w[089c527c61235bd0793c49109b5bd34d439848c6
-                                                          b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
-                                                          2e9366dd7a786fdb35f211fff1c8ea05c51968b1
-                                                          1df547800dcd168e589bb9b26b4039bff3a7f7e4
-                                                          a2690f4471a0852723f0f0e95d97f7f1f3981639]
+      assert_equal git.activity.commits.collect(&:token), %w[089c527c61235bd0793c49109b5bd34d439848c6
+                                                             b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
+                                                             2e9366dd7a786fdb35f211fff1c8ea05c51968b1
+                                                             1df547800dcd168e589bb9b26b4039bff3a7f7e4
+                                                             a2690f4471a0852723f0f0e95d97f7f1f3981639]
 
-      git.activity.commits(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1').collect(&:token)
-         .must_equal %w[1df547800dcd168e589bb9b26b4039bff3a7f7e4 a2690f4471a0852723f0f0e95d97f7f1f3981639]
+      assert_equal git.activity.commits(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1').collect(&:token),
+                   %w[1df547800dcd168e589bb9b26b4039bff3a7f7e4 a2690f4471a0852723f0f0e95d97f7f1f3981639]
 
-      git.activity.commits(after: 'a2690f4471a0852723f0f0e95d97f7f1f3981639').must_be :empty?
+      assert_empty git.activity.commits(after: 'a2690f4471a0852723f0f0e95d97f7f1f3981639')
     end
   end
 
   it 'commits for branch' do
     with_git_repository('git', 'develop') do |git|
-      git.activity.commits.map(&:token).must_equal %w[089c527c61235bd0793c49109b5bd34d439848c6
-                                                      b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
-                                                      2e9366dd7a786fdb35f211fff1c8ea05c51968b1
-                                                      b4046b9a80fead62fa949232f2b87b0cb78fffcc]
+      assert_equal git.activity.commits.map(&:token), %w[089c527c61235bd0793c49109b5bd34d439848c6
+                                                         b6e9220c3cabe53a4ed7f32952aeaeb8a822603d
+                                                         2e9366dd7a786fdb35f211fff1c8ea05c51968b1
+                                                         b4046b9a80fead62fa949232f2b87b0cb78fffcc]
 
-      git.activity.commits(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1')
-         .map(&:token).must_equal ['b4046b9a80fead62fa949232f2b87b0cb78fffcc']
+      assert_equal git.activity.commits(after: '2e9366dd7a786fdb35f211fff1c8ea05c51968b1')
+                      .map(&:token), ['b4046b9a80fead62fa949232f2b87b0cb78fffcc']
 
-      git.activity.commits(after: 'b4046b9a80fead62fa949232f2b87b0cb78fffcc').must_be :empty?
+      assert_empty git.activity.commits(after: 'b4046b9a80fead62fa949232f2b87b0cb78fffcc')
     end
   end
 
@@ -149,44 +149,44 @@ describe 'Git::Activity' do
       submodule_commits = %w[240375de181498b9a34d4bd328f2c87d2ade79f9
                              b6a80291e49dc540bb78526f9b1aab1123c9fb0e]
 
-      (git.activity.commit_tokens & submodule_commits).must_be :empty?
+      assert_empty(git.activity.commit_tokens & submodule_commits)
 
       diffs = git.activity.commits.map(&:diffs).reject(&:empty?).flatten
-      diffs.map(&:path).must_equal ['A']
-      diffs.map(&:sha1).must_equal ['f70f10e4db19068f79bc43844b49f3eece45c4e8']
+      assert_equal diffs.map(&:path), ['A']
+      assert_equal diffs.map(&:sha1), ['f70f10e4db19068f79bc43844b49f3eece45c4e8']
     end
   end
 
   it 'commit_count for trunk commits' do
     with_git_repository('git_dupe_delete') do |git|
-      git.activity.commit_count(trunk_only: false).must_equal 4
-      git.activity.commit_count(trunk_only: true).must_equal 3
+      assert_equal git.activity.commit_count(trunk_only: false), 4
+      assert_equal git.activity.commit_count(trunk_only: true), 3
     end
   end
 
   it 'commit tokens for trunk commits' do
     with_git_repository('git_dupe_delete') do |git|
-      git.activity.commit_tokens(trunk_only: false).must_equal ['a0a2b8623941562031a7d7f95d984feb4a2d719c',
-                                                                'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
-                                                                '6126337d2497806528fd8657181d5d4afadd72a4', # On branch
-                                                                '41c4b1044ebffc968d363e5f5e883134e624f846']
+      assert_equal git.activity.commit_tokens(trunk_only: false),
+                   ['a0a2b8623941562031a7d7f95d984feb4a2d719c', 'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
+                    '6126337d2497806528fd8657181d5d4afadd72a4', # On branch
+                    '41c4b1044ebffc968d363e5f5e883134e624f846']
 
-      git.activity.commit_tokens(trunk_only: true).must_equal ['a0a2b8623941562031a7d7f95d984feb4a2d719c',
-                                                               'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
-                                                               # '6126337d2497806528fd8657181d5d4afadd72a4' # On branch
-                                                               '41c4b1044ebffc968d363e5f5e883134e624f846']
+      assert_equal git.activity.commit_tokens(trunk_only: true),
+                   ['a0a2b8623941562031a7d7f95d984feb4a2d719c', 'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
+                    # '6126337d2497806528fd8657181d5d4afadd72a4' # On branch
+                    '41c4b1044ebffc968d363e5f5e883134e624f846']
     end
   end
 
   it 'commit tokens for trunk commits using after' do
     with_git_repository('git_dupe_delete') do |git|
-      git.activity.commit_tokens(after: 'a0a2b8623941562031a7d7f95d984feb4a2d719c',
-                                 trunk_only: true).must_equal %w[ad6bb43112706c462e53a9a8a8cd3b05f8e9260f
-                                                                 41c4b1044ebffc968d363e5f5e883134e624f846]
+      assert_equal git.activity.commit_tokens(after: 'a0a2b8623941562031a7d7f95d984feb4a2d719c',
+                                              trunk_only: true), %w[ad6bb43112706c462e53a9a8a8cd3b05f8e9260f
+                                                                    41c4b1044ebffc968d363e5f5e883134e624f846]
 
       # All trunk commit_tokens, with :after == HEAD
-      git.activity.commit_tokens(after: '41c4b1044ebffc968d363e5f5e883134e624f846',
-                                 trunk_only: true).must_be :empty?
+      assert_empty git.activity.commit_tokens(after: '41c4b1044ebffc968d363e5f5e883134e624f846',
+                                              trunk_only: true)
     end
   end
 
@@ -194,24 +194,24 @@ describe 'Git::Activity' do
     # `git mv foo bar` results in a single R diff. Split it into A & D diffs.
     with_git_repository('git_with_mv') do |git|
       r_commit = git.activity.commits[-2]
-      r_commit.message.strip.must_equal 'Ran: git mv foo bar'
-      r_commit.diffs.map(&:action).must_equal %w[D A]
-      r_commit.diffs.map(&:path).must_equal %w[foo bar]
+      assert_equal r_commit.message.strip, 'Ran: git mv foo bar'
+      assert_equal r_commit.diffs.map(&:action), %w[D A]
+      assert_equal r_commit.diffs.map(&:path), %w[foo bar]
 
       r_commit = git.activity.commits.last
-      r_commit.message.strip.must_equal 'Ran: echo B >> bar; mv bar rab'
-      r_commit.diffs.map(&:action).must_equal %w[D A]
-      r_commit.diffs.map(&:path).must_equal %w[bar rab]
+      assert_equal r_commit.message.strip, 'Ran: echo B >> bar; mv bar rab'
+      assert_equal r_commit.diffs.map(&:action), %w[D A]
+      assert_equal r_commit.diffs.map(&:path), %w[bar rab]
     end
   end
 
   it 'trunk only commits' do
     with_git_repository('git_dupe_delete') do |git|
-      git.activity.commits(trunk_only: true).collect(&:token).must_equal ['a0a2b8623941562031a7d7f95d984feb4a2d719c',
-                                                                          'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
-                                                                          # on a branch, hence excluded.
-                                                                          # '6126337d2497806528fd8657181d5d4afadd72a4',
-                                                                          '41c4b1044ebffc968d363e5f5e883134e624f846']
+      assert_equal git.activity.commits(trunk_only: true).collect(&:token),
+                   ['a0a2b8623941562031a7d7f95d984feb4a2d719c', 'ad6bb43112706c462e53a9a8a8cd3b05f8e9260f',
+                    # on a branch, hence excluded.
+                    # '6126337d2497806528fd8657181d5d4afadd72a4',
+                    '41c4b1044ebffc968d363e5f5e883134e624f846']
     end
   end
 
@@ -229,14 +229,14 @@ describe 'Git::Activity' do
     with_git_repository('git_with_null_merge') do |git|
       c = git.activity.verbose_commit('d3bd0bedbf4b197b2c4eb827e1ec4c35b834482f')
       # This commit's tree is identical to its parent's. Thus it should contain no diffs.
-      c.diffs.must_equal []
+      assert_equal c.diffs, []
     end
   end
 
   it 'each commit with null merge' do
     with_git_repository('git_with_null_merge') do |git|
       git.activity.each_commit do |c|
-        c.diffs.must_equal [] if c.token == 'd3bd0bedbf4b197b2c4eb827e1ec4c35b834482f'
+        assert_equal c.diffs, [] if c.token == 'd3bd0bedbf4b197b2c4eb827e1ec4c35b834482f'
       end
     end
   end
@@ -250,29 +250,29 @@ describe 'Git::Activity' do
   it 'safe_open_log_file must return text with valid encoding' do
     with_git_repository('git_with_invalid_encoding') do |git|
       git.activity.send(:safe_open_log_file) do |io|
-        io.read.valid_encoding?.must_equal true
+        assert_equal io.read.valid_encoding?, true
       end
     end
   end
 
   it 'commit count when there is a tag named master' do
     with_git_repository('git_with_master_tag') do |git|
-      git.activity.commit_count.must_equal 3
+      assert_equal git.activity.commit_count, 3
     end
   end
 
   it 'commit tokens when there is a tag named master' do
     with_git_repository('git_with_master_tag') do |git|
-      git.activity.commit_tokens.must_equal %w[57b2bd30b7bae970cb3b374a0c05fd6ec3088ebf
-                                               4e95717ac8cff8cdb10d83398d3ac667a2cca341
-                                               34b8a99e6e5dd39bc36893f71e0ab1685668731f]
+      assert_equal git.activity.commit_tokens, %w[57b2bd30b7bae970cb3b374a0c05fd6ec3088ebf
+                                                  4e95717ac8cff8cdb10d83398d3ac667a2cca341
+                                                  34b8a99e6e5dd39bc36893f71e0ab1685668731f]
     end
   end
 
   it 'must cat file correctly' do
     with_git_repository('git') do |core|
       diff = OhlohScm::Diff.new(sha1: '4c734ad53b272c9b3d719f214372ac497ff6c068')
-      core.activity.cat_file(nil, diff).must_equal <<-EXPECTED.gsub(/^ {8}/, '')
+      assert_equal core.activity.cat_file(nil, diff), <<-EXPECTED.gsub(/^ {8}/, '')
         /* Hello, World! */
         #include <stdio.h>
         main()
@@ -288,23 +288,23 @@ describe 'Git::Activity' do
       with_git_repository('git_walk') do |git|
         commit_tokens = CommitTokensHelper.new(git, commit_labels)
         # Full history to a commit
-        commit_tokens.between(nil, :A).must_equal %i[A]
-        commit_tokens.between(nil, :B).must_equal %i[A B]
-        commit_tokens.between(nil, :C).must_equal %i[A B G H C]
-        commit_tokens.between(nil, :D).must_equal %i[A B G H C I D]
-        commit_tokens.between(nil, :G).must_equal %i[A G]
-        commit_tokens.between(nil, :H).must_equal %i[A G H]
-        commit_tokens.between(nil, :I).must_equal %i[A G H I]
-        commit_tokens.between(nil, :J).must_equal %i[A G H I J]
+        assert_equal commit_tokens.between(nil, :A), %i[A]
+        assert_equal commit_tokens.between(nil, :B), %i[A B]
+        assert_equal commit_tokens.between(nil, :C), %i[A B G H C]
+        assert_equal commit_tokens.between(nil, :D), %i[A B G H C I D]
+        assert_equal commit_tokens.between(nil, :G), %i[A G]
+        assert_equal commit_tokens.between(nil, :H), %i[A G H]
+        assert_equal commit_tokens.between(nil, :I), %i[A G H I]
+        assert_equal commit_tokens.between(nil, :J), %i[A G H I J]
 
         # Limited history from one commit to another
-        commit_tokens.between(:A, :A).must_be :empty?
-        commit_tokens.between(:A, :B).must_equal %i[B]
-        commit_tokens.between(:A, :C).must_equal %i[B G H C]
-        commit_tokens.between(:A, :D).must_equal %i[B G H C I D]
-        commit_tokens.between(:B, :D).must_equal %i[G H C I D]
-        commit_tokens.between(:C, :D).must_equal %i[I D]
-        commit_tokens.between(:G, :J).must_equal %i[H I J]
+        assert_empty commit_tokens.between(:A, :A)
+        assert_equal commit_tokens.between(:A, :B), %i[B]
+        assert_equal commit_tokens.between(:A, :C), %i[B G H C]
+        assert_equal commit_tokens.between(:A, :D), %i[B G H C I D]
+        assert_equal commit_tokens.between(:B, :D), %i[G H C I D]
+        assert_equal commit_tokens.between(:C, :D), %i[I D]
+        assert_equal commit_tokens.between(:G, :J), %i[H I J]
       end
     end
 
@@ -312,18 +312,18 @@ describe 'Git::Activity' do
       with_git_repository('git_walk') do |git|
         commit_tokens = CommitTokensHelper.new(git, commit_labels, trunk_only: true)
         # Full history to a commit
-        commit_tokens.between(nil, :A).must_equal %i[A]
-        commit_tokens.between(nil, :B).must_equal %i[A B]
-        commit_tokens.between(nil, :C).must_equal %i[A B C]
-        commit_tokens.between(nil, :D).must_equal %i[A B C D]
+        assert_equal commit_tokens.between(nil, :A), %i[A]
+        assert_equal commit_tokens.between(nil, :B), %i[A B]
+        assert_equal commit_tokens.between(nil, :C), %i[A B C]
+        assert_equal commit_tokens.between(nil, :D), %i[A B C D]
 
         # Limited history from one commit to another
-        commit_tokens.between(:A, :A).must_be :empty?
-        commit_tokens.between(:A, :B).must_equal %i[B]
-        commit_tokens.between(:A, :C).must_equal %i[B C]
-        commit_tokens.between(:A, :D).must_equal %i[B C D]
-        commit_tokens.between(:B, :D).must_equal %i[C D]
-        commit_tokens.between(:C, :D).must_equal %i[D]
+        assert_empty commit_tokens.between(:A, :A)
+        assert_equal commit_tokens.between(:A, :B), %i[B]
+        assert_equal commit_tokens.between(:A, :C), %i[B C]
+        assert_equal commit_tokens.between(:A, :D), %i[B C D]
+        assert_equal commit_tokens.between(:B, :D), %i[C D]
+        assert_equal commit_tokens.between(:C, :D), %i[D]
       end
     end
 
@@ -333,8 +333,9 @@ describe 'Git::Activity' do
 
         core.activity.send(:init_db)
         refute core.activity.send(:anything_to_commit?)
-
+        # rubocop:disable Lint/EmptyBlock
         File.open(File.join(dir, 'README'), 'w') {}
+        # rubocop:enable Lint/EmptyBlock
         assert core.activity.send(:anything_to_commit?)
 
         c = OhlohScm::Commit.new
@@ -343,12 +344,12 @@ describe 'Git::Activity' do
         core.activity.commit_all(c)
         refute core.activity.send(:anything_to_commit?)
 
-        core.activity.commits.size.must_equal 1
+        assert_equal core.activity.commits.size, 1
 
-        core.activity.commits.first.author_name.must_equal c.author_name
+        assert_equal core.activity.commits.first.author_name, c.author_name
         # Depending on version of Git used, we may or may not have trailing \n.
         # We don't really care, so just compare the stripped versions.
-        core.activity.commits.first.message.strip.must_equal c.message.strip
+        assert_equal core.activity.commits.first.message.strip, c.message.strip
 
         assert_equal ['.gitignore', 'README'], core.activity.commits.first.diffs.collect(&:path).sort
       end
@@ -370,7 +371,7 @@ describe 'Git::Activity' do
         core.activity.send(:write_token, 'FOO')
         refute core.activity.read_token # Token not valid until committed
         core.activity.commit_all(OhlohScm::Commit.new)
-        core.activity.read_token.must_equal 'FOO'
+        assert_equal core.activity.read_token, 'FOO'
       end
     end
 
@@ -381,7 +382,7 @@ describe 'Git::Activity' do
         c = OhlohScm::Commit.new
         c.token = 'BAR'
         core.activity.commit_all(c)
-        c.token.must_equal core.activity.read_token
+        assert_equal c.token, core.activity.read_token
       end
     end
 

data/spec/ohloh_scm/git/scm_spec.rb

@@ -27,8 +27,8 @@ describe 'Git::Scm' do
         master_branch_sha = `cd #{dest_dir} && git rev-parse master`
         test_branch_sha = `cd #{dest_dir} && git rev-parse test`
 
-        master_branch_sha.wont_equal test_branch_sha
-        master_branch_sha.must_equal remote_master_branch_sha
+        refute_equal master_branch_sha, test_branch_sha
+        assert_equal master_branch_sha, remote_master_branch_sha
       end
     end
   end
@@ -48,8 +48,8 @@ describe 'Git::Scm' do
         master_branch_sha = `cd #{dest_dir} && git rev-parse master`
         test_branch_sha = `cd #{dest_dir} && git rev-parse test`
 
-        master_branch_sha.must_equal remote_master_branch_sha
-        test_branch_sha.must_equal remote_test_branch_sha
+        assert_equal master_branch_sha, remote_master_branch_sha
+        assert_equal test_branch_sha, remote_test_branch_sha
       end
     end
   end
@@ -80,12 +80,12 @@ describe 'Git::Scm' do
         # Emulate a scenario where the local copy doesn't have the current *main* branch.
         `cd #{dest_dir} && git checkout master && git branch -D test`
 
-        local_branch_cmd = "cd #{dest_dir} && git branch | grep '\*' | sed 's/^\* //'"
-        `#{ local_branch_cmd }`.chomp.must_equal 'master'
+        local_branch_cmd = "cd #{dest_dir} && git branch | grep '*' | sed 's/^* //'"
+        assert_equal `#{local_branch_cmd}`.chomp, 'master'
 
         # On doing a refetch, our local copy will now have the updated *main* branch.
         core.scm.pull(src_core.scm, TestCallback.new)
-        `#{ local_branch_cmd }`.chomp.must_equal test_branch_name
+        assert_equal `#{local_branch_cmd}`.chomp, test_branch_name
       end
     end
   end
@@ -103,12 +103,12 @@ describe 'Git::Scm' do
         src_core.activity.commits.each_with_index do |c, i|
           # Because CVS does not track authors (only committers),
           # the CVS committer becomes the Git author.
-          c.committer_date.must_equal dest_commits[i].author_date
-          c.committer_name.must_equal dest_commits[i].author_name
+          assert_equal c.committer_date, dest_commits[i].author_date
+          assert_equal c.committer_name, dest_commits[i].author_name
 
           # Depending upon version of Git used, we may or may not have a trailing \n.
           # We don't really care, so just compare the stripped versions.
-          c.message.strip.must_equal dest_commits[i].message.strip
+          assert_equal c.message.strip, dest_commits[i].message.strip
         end
       end
     end
@@ -129,6 +129,6 @@ describe 'Git::Scm' do
 
   it 'must return master when branch_name is null' do
     core = OhlohScm::Factory.get_core(scm_type: :git, url: 'foobar')
-    _(core.scm.branch_name_or_default).must_equal 'master'
+    assert_equal core.scm.branch_name_or_default, 'master'
   end
 end

data/spec/ohloh_scm/git/status_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Git::Status' do
   it 'branch?' do
     with_git_repository('git') do |git|
-      git.activity.send(:branches).must_equal %w[develop master]
+      assert_equal git.activity.send(:branches), %w[develop master]
       assert git.status.branch?('master')
       assert git.status.branch?('develop')
     end
@@ -13,13 +13,13 @@ describe 'Git::Status' do
     it 'must return default branch when repository doesnt exist' do
       git = OhlohScm::Factory.get_core(scm_type: :git, url: 'foobar')
       git.status.stubs(:exist?)
-      _(git.status.default_branch).must_equal 'master'
+      assert_equal git.status.default_branch, 'master'
     end
 
     it 'must return default branch when no HEAD branch is found in remote' do
       git = OhlohScm::Factory.get_core(scm_type: :git, url: 'foobar')
       git.status.stubs(:exist?).returns(true)
-      git.status.default_branch.must_equal 'master'
+      assert_equal git.status.default_branch, 'master'
     end
   end
 end

data/spec/ohloh_scm/git/validation_spec.rb

@@ -4,22 +4,22 @@ describe 'Git::Validation' do
   it 'wont have errors for valid url' do
     core = OhlohScm::Factory.get_core(scm_type: :git, url: 'https://github.com/ruby/ruby')
     core.validation.send(:validate_attributes)
-    core.errors.must_be :empty?
+    assert_empty core.errors
   end
 
   it 'must have errors for invalid branch_name' do
-    get_core(:git, branch_name: 'x' * 81).validation.send(:branch_name_errors).wont_be :empty?
-    get_core(:git, branch_name: 'foo@bar').validation.send(:branch_name_errors).wont_be :empty?
+    refute_empty get_core(:git, branch_name: 'x' * 81).validation.send(:branch_name_errors)
+    refute_empty get_core(:git, branch_name: 'foo@bar').validation.send(:branch_name_errors)
   end
 
   it 'must have errors for invalid username' do
-    get_core(:git, username: 'x' * 33).validation.send(:username_errors).wont_be :empty?
-    get_core(:git, username: 'foo@bar').validation.send(:username_errors).wont_be :empty?
+    refute_empty get_core(:git, username: 'x' * 33).validation.send(:username_errors)
+    refute_empty get_core(:git, username: 'foo@bar').validation.send(:username_errors)
   end
 
   it 'must have errors for invalid password' do
-    get_core(:git, password: 'x' * 33).validation.send(:password_errors).wont_be :empty?
-    get_core(:git, password: 'escape').validation.send(:password_errors).wont_be :empty?
+    refute_empty get_core(:git, password: 'x' * 33).validation.send(:password_errors)
+    refute_empty get_core(:git, password: 'escape').validation.send(:password_errors)
   end
 
   describe 'validate url' do

data/spec/ohloh_scm/git_svn/activity_spec.rb

@@ -4,16 +4,16 @@ require 'mocha'
 describe 'GitSvn::Activity' do
   it 'must return all commit tokens' do
     with_git_svn_repository('git_svn') do |git_svn|
-      git_svn.activity.commit_tokens.must_equal [1, 2, 3, 5]
-      git_svn.activity.commit_tokens(after: 2).must_equal [3, 5]
+      assert_equal git_svn.activity.commit_tokens, [1, 2, 3, 5]
+      assert_equal git_svn.activity.commit_tokens(after: 2), [3, 5]
     end
   end
 
   it 'must return commits' do
     with_git_svn_repository('git_svn') do |git_svn|
-      git_svn.activity.commits.map(&:token).must_equal [1, 2, 3, 5]
-      git_svn.activity.commits(after: 2).map(&:token).must_equal [3, 5]
-      git_svn.activity.commits(after: 7).map(&:token).must_equal []
+      assert_equal git_svn.activity.commits.map(&:token), [1, 2, 3, 5]
+      assert_equal git_svn.activity.commits(after: 2).map(&:token), [3, 5]
+      assert_equal git_svn.activity.commits(after: 7).map(&:token), []
     end
   end
 
@@ -21,19 +21,19 @@ describe 'GitSvn::Activity' do
     with_git_svn_repository('git_svn') do |git_svn|
       commits = []
       git_svn.activity.each_commit { |c| commits << c }
-      git_svn.activity.commits.map(&:token).must_equal [1, 2, 3, 5]
+      assert_equal git_svn.activity.commits.map(&:token), [1, 2, 3, 5]
     end
   end
 
   it 'must return total commit count' do
     with_git_svn_repository('git_svn') do |git_svn|
-      git_svn.activity.commit_count.must_equal 4
-      git_svn.activity.commit_count(after: 2).must_equal 2
+      assert_equal git_svn.activity.commit_count, 4
+      assert_equal git_svn.activity.commit_count(after: 2), 2
     end
   end
 
   describe 'cat' do
-    let(:commit_1) { OhlohScm::Commit.new(token: 1) }
+    let(:commit1) { OhlohScm::Commit.new(token: 1) }
     let(:hello_diff) { OhlohScm::Diff.new(path: 'helloworld.c') }
 
     it 'cat_file' do
@@ -47,8 +47,8 @@ describe 'GitSvn::Activity' do
           }
         EXPECTED
 
-        git_svn.activity.cat_file(commit_1, hello_diff)
-               .delete("\t").strip.must_equal expected.strip
+        assert_equal git_svn.activity.cat_file(commit1, hello_diff)
+                            .delete("\t").strip, expected.strip
       end
     end
 
@@ -60,7 +60,7 @@ describe 'GitSvn::Activity' do
 
     it 'cat_file_with_invalid_filename' do
       with_git_svn_repository('git_svn') do |git_svn|
-        assert git_svn.activity.cat_file(commit_1, OhlohScm::Diff.new(path: 'invalid')).must_be_empty
+        assert_empty git_svn.activity.cat_file(commit1, OhlohScm::Diff.new(path: 'invalid'))
       end
     end
 
@@ -76,13 +76,13 @@ describe 'GitSvn::Activity' do
         EXPECTED
 
         commit = OhlohScm::Commit.new(token: 2)
-        git_svn.activity.cat_file_parent(commit, hello_diff).delete("\t").must_equal expected.strip
+        assert_equal git_svn.activity.cat_file_parent(commit, hello_diff).delete("\t"), expected.strip
       end
     end
 
     it 'cat_file_parent_with_first_token' do
       with_git_svn_repository('git_svn') do |git_svn|
-        assert git_svn.activity.cat_file(commit_1, hello_diff)
+        assert git_svn.activity.cat_file(commit1, hello_diff)
       end
     end
   end

data/spec/ohloh_scm/git_svn/scm_spec.rb

@@ -8,7 +8,7 @@ describe 'GitSvn::Scm' do
         git_svn.scm.pull(src.scm, TestCallback.new)
         assert git_svn.status.exist?
 
-        git_svn.activity.commit_count.must_equal 5
+        assert_equal git_svn.activity.commit_count, 5
       end
     end
   end