wikipedia-vandalism_detection 0.1.0-java

data/spec/vandalism_detection/feature_calculator_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::FeatureCalculator do
+  let(:edit) { build(:edit) }
+
+  it 'raises NoFeaturesConfiguredError when no features are configured' do
+    config = Wikipedia::VandalismDetection::Configuration.send(:new)
+    config.instance_variable_set(:@features, nil)
+
+    use_configuration(config)
+
+    expect { Wikipedia::VandalismDetection::FeatureCalculator.new }
+      .to raise_error Wikipedia::VandalismDetection::FeaturesNotConfiguredError
+  end
+
+  before do
+    use_test_configuration
+    @calculator = Wikipedia::VandalismDetection::FeatureCalculator.new
+  end
+
+  describe '#calculate_features_for' do
+    it { is_expected.to respond_to :calculate_features_for }
+
+    it 'takes an edit as parameter' do
+      expect { @calculator.calculate_features_for(edit) }
+        .not_to raise_error ArgumentError
+    end
+
+    it 'raises an error if called with wrong parameter type' do
+      revision = build(:empty_revision)
+      expect { @calculator.calculate_features_for(revision) }
+        .to raise_error ArgumentError
+    end
+
+    it 'returns an array' do
+      expect(@calculator.calculate_features_for(edit)).to be_an Array
+    end
+
+    it 'returns the computed numeric feature values' do
+      feature_values = @calculator.calculate_features_for(edit)
+      expect(feature_values.all? { |value| value.is_a?(Numeric) }).to be true
+    end
+
+    it 'returns the right number of feature values' do
+      count = @calculator.used_features.count
+      expect(@calculator.calculate_features_for(edit).count).to eq count
+    end
+
+    it 'uses the cleaned up text if revision contains a #REDIRECT' do
+      redirect_text = Text.new('#REDIRECT [[Redirect page]]')
+      old_revision_redirect = build(:old_revision, text: redirect_text)
+      new_revision_redirect = build(:new_revision, text: redirect_text)
+      old_revision = build(:old_revision)
+      new_revision = build(:new_revision)
+
+      edit_a = Wikipedia::VandalismDetection::Edit.new(old_revision_redirect, new_revision)
+      edit_b = Wikipedia::VandalismDetection::Edit.new(old_revision, new_revision_redirect)
+
+      config = Wikipedia::VandalismDetection.config
+      count = config.features.count
+
+      expect(@calculator.calculate_features_for(edit_a).count).to eq count
+      expect(@calculator.calculate_features_for(edit_b).count).to eq count
+    end
+
+    it 'includes -1 for not extractable texts in either revision' do
+      config = Wikipedia::VandalismDetection::Configuration.instance
+      config.instance_variable_set(:@features, ['all wordlists impact'])
+
+      use_configuration(config)
+
+      unparsable_wiki_text = Text.new("[[Image:img.jpg|\n{|\n|-\n|||| |}")
+
+      old_revision_unparsable = build(:old_revision, text: unparsable_wiki_text)
+      new_revision_unparsable = build(:new_revision, text: unparsable_wiki_text)
+
+      old_revision = build(:old_revision)
+      new_revision = build(:new_revision)
+
+      edit_a = Wikipedia::VandalismDetection::Edit.new(old_revision_unparsable, new_revision)
+      edit_b = Wikipedia::VandalismDetection::Edit.new(old_revision, new_revision_unparsable)
+
+      expect(subject.calculate_features_for(edit_a)).to include Features::MISSING_VALUE
+      expect(subject.calculate_features_for(edit_b)).to include Features::MISSING_VALUE
+    end
+  end
+
+  describe '#claculate_feature_for' do
+    let(:feature_name) { 'anonymity' }
+    let(:random_number) { rand(1000) }
+    let(:empty_revision) { build(:empty_revision) }
+
+    before do
+      allow_any_instance_of(Features::Anonymity)
+        .to receive(:calculate)
+        .and_return(random_number)
+    end
+
+    it { is_expected.to respond_to :calculate_feature_for }
+
+    it 'takes an edit and feature name as parameter' do
+      expect { @calculator.calculate_feature_for(edit, feature_name) }
+        .not_to raise_error ArgumentError
+    end
+
+    it 'raises an error if called with wrong parameter type edit' do
+      expect { @calculator.calculate_feature_for(empty_revision, feature_name) }
+        .to raise_error ArgumentError
+    end
+
+    it 'raises an error if called with wrong parameter type feature name' do
+      expect { @calculator.calculate_feature_for(edit, empty_revision) }
+        .to raise_error ArgumentError
+    end
+
+    it 'returns a Numeric' do
+      expect(@calculator.calculate_feature_for(edit, feature_name))
+        .to be_a Numeric
+    end
+
+    it 'returns the value calculated by the feature class' do
+      expect(@calculator.calculate_feature_for(edit, feature_name))
+        .to eq random_number
+    end
+  end
+
+  describe '#used_features' do
+    it { is_expected.to respond_to :used_features }
+
+    it 'returns an array of the features defined in the config feature.yml' do
+      features = Wikipedia::VandalismDetection.config.features
+      expect(@calculator.used_features).to match_array features
+    end
+  end
+end

data/spec/vandalism_detection/features/all_wordlists_frequency_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::AllWordlistsFrequency do
+  it { is_expected.to be_a Features::FrequencyBase }
+
+  describe '#calculate' do
+    it 'returns the inserted number of all lists words over all inserted' do
+      # inserted: total 7 words, 1 vulgarism, 1 biased, 1 pronouns = 3 bad
+      old_text = Text.new('Your old shit. ')
+      new_text = Text.new('Your old shit. Fuck you great, and all the others.')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 3.0 / 7.0
+    end
+
+    it 'returns 0.0 on empty clean inserted text' do
+      old_text = Text.new('Your old shit. ')
+      new_text = Text.new('Your old shit. {{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/all_wordlists_impact_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::AllWordlistsImpact do
+  it { is_expected.to be_a Features::ImpactBase }
+
+  describe '#calculate' do
+    it 'returns the impact of all wordlists words of the new revision text' do
+      # 1 vulgarism, 2 pronouns, 0 biased = 3 bad
+      old_text = Text.new('Fuck you, you and all the others')
+      # 3 vulgarism, 3 pronouns, 1 biased = 7 bad
+      new_text = Text.new('Fuck you great, fuck you, you all others sluts')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 3.0 / (3.0 + 7.0)
+    end
+
+    it 'returns 0.5 if both text revisions have no terms' do
+      text = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: text)
+      new_rev = build(:new_revision, text: text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.5
+    end
+
+    it 'returns 0.0 for an emtpy clean text in the old revision' do
+      old_text = Text.new('{{speedy deletion}}')
+      new_text = Text.new('fuck')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+
+    it 'returns 1.0 for an emtpy clean text in the new revision' do
+      old_text = Text.new('fuck')
+      new_text = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 1.0
+    end
+  end
+end

data/spec/vandalism_detection/features/anonymity_previous_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::AnonymityPrevious do
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    context 'both contributors are given' do
+      it 'return 1.0 in case of an registered previous editor' do
+        old_rev = build(:old_revision, contributor: 'Peter')
+        new_rev = build(:new_revision)
+        edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+        expect(subject.calculate(edit)).to eq 1
+      end
+
+      it 'returns 0.0 in case of an anonymous previous editor' do
+        old_rev = build(:old_revision, contributor: '137.163.16.199')
+        new_rev = build(:new_revision)
+        edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+        expect(subject.calculate(edit)).to eq 0
+      end
+    end
+
+    context 'previous contributor not given' do
+      context 'for a registered previous editor' do
+        it 'requests the user from Wikipedia API and returns 1' do
+          old_rev = build(:old_revision, id: '324557983', contributor: nil)
+          new_rev = build(
+            :new_revision,
+            id: '329962649',
+            parent_id: '324557983',
+            contributor: 'Tomaxer'
+          )
+
+          edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+          expect(subject.calculate(edit)).to eq 1
+        end
+      end
+
+      context 'for an anonymous previous editor' do # also same editor!
+        it 'requests the user from Wikipedia API and returns 0' do
+          old_rev = build(:old_revision, id: '328774110', contributor: nil)
+          new_rev = build(:new_revision, id: '328774035', parent_id: '328774110')
+          edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+          expect(subject.calculate(edit)).to eq 0
+        end
+      end
+
+      context 'if old reivision is not available anymore' do
+        it 'returns missing' do
+          # to get api call, see:
+          # https://en.wikipedia.org/w/api.php?action=query&prop=revisions&rvprop=timestamp&revids=325218985
+          # <rev revid="325218985"/>
+
+          old_rev = build(:old_revision, id: '325218985', contributor: nil)
+          new_rev = build(:new_revision, id: '326980599', parent_id: '325218985')
+          edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+          expect(subject.calculate(edit)).to eq Features::MISSING_VALUE
+        end
+      end
+    end
+  end
+end

data/spec/vandalism_detection/features/anonymity_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::Anonymity do
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    it 'return 1.0 in case of an registered editor' do
+      edit = build :edit, new_revision: build(:registered_revision)
+      expect(subject.calculate(edit)).to eq 1
+    end
+
+    it 'returns 0.0 in case of an anonymous editor' do
+      edit = build :edit, new_revision: build(:anonymous_revision)
+      expect(subject.calculate(edit)).to eq 0
+    end
+  end
+end

data/spec/vandalism_detection/features/article_size_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::ArticleSize do
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    it 'returns the size of the edit’s new revisions' do
+      old_rev_text = Text.new('123')
+      new_rev_text = Text.new('123 456789') # size 10 (with spaces)
+
+      old_rev = build(:old_revision, text: old_rev_text)
+      new_rev = build(:new_revision, text: new_rev_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 10
+    end
+
+    it "returns 0 if the edit's new revisions is empty" do
+      old_rev_text = Text.new('123')
+      new_rev_text = Text.new # size 0
+
+      old_rev = build(:old_revision, text: old_rev_text)
+      new_rev = build(:new_revision, text: new_rev_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 0
+    end
+  end
+end

data/spec/vandalism_detection/features/bad_frequency_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BadFrequency do
+  it { is_expected.to be_a Features::FrequencyBase }
+
+  describe '#calculate' do
+    it 'returns the number of vulgarism words relative to all words count' do
+      # total 6 words, 3 bad
+      old_text = Text.new('Old whatever.')
+      new_text = Text.new('Old whatever. New ugly contents. Hi, gotta fun.')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 3.0 / 6.0
+    end
+
+    it 'returns 0.0 for an emtpy clean text in the new revision' do
+      old_text = Text.new('Old guy.')
+      new_text = Text.new('Old guy. {{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/bad_impact_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BadImpact do
+  it { is_expected.to be_a Features::ImpactBase }
+
+  describe '#calculate' do
+    it 'returns the impact of bad words of the edit’s new revision text' do
+      # 3 bad words
+      old_text = Text.new('Hi, old text 666, dont know')
+
+      # 4 bad words
+      new_text = Text.new('Hi, new text dosent, whatever, guy')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 3.0 / (3.0 + 4.0)
+    end
+
+    it 'returns 0.5 on both no terms in text revisions' do
+      text = Text.new('{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: text)
+      new_rev = build(:new_revision, text: text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.5
+    end
+
+    it 'returns 0.0 on emtpy clean text of old revision' do
+      old_text = Text.new('{{speedy deletion}}')
+      new_text = Text.new('Guy')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+
+    it 'returns 1.0 on emtpy clean text of new revision' do
+      old_text = Text.new('Guy')
+      new_text = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 1.0
+    end
+  end
+end

data/spec/vandalism_detection/features/base_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::Base do
+  describe '#count' do
+    let(:text) { 'I,  you: i will help You' }
+
+    it { is_expected.to respond_to(:count).with(2).arguments }
+
+    it 'raises an error if option :in is not defined' do
+      expect { subject.count(%i[i you], from: text) }
+        .to raise_error ArgumentError
+    end
+
+    it 'raises an error if terms is not an Array or String' do
+      expect { subject.count({ term: 'You' }, in: text) }
+        .to raise_error ArgumentError
+    end
+
+    it 'returns the total number of terms found for the given terms array' do
+      terms = %i[i you]
+      expect(subject.count(terms, in: text)).to eq 4
+    end
+
+    it 'returns the number of terms found for the given single term' do
+      expect(subject.count('You', in: text)).to eq 2
+    end
+  end
+
+  describe '#calculate' do
+    it { is_expected.to respond_to :calculate }
+
+    it 'takes an Wikipedia::Edit as argument' do
+      edit = build(:edit)
+      expect { subject.calculate(edit) }.not_to raise_error ArgumentError
+    end
+
+    it 'raises an ArgumentError if argument is no Wikipedia::Edit' do
+      expect { subject.calculate('string') }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/vandalism_detection/features/biased_frequency_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BiasedFrequency do
+  it { is_expected.to be_a Features::FrequencyBase }
+
+  describe '#calculate' do
+    it 'returns the inserted number of biased words over all inserted words' do
+      # inserted: total 7 words, 3 biased
+      old_text = Text.new('Great old.')
+      new_text = Text.new('Great old. This is so great, really a classic.')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 3.0 / 7.0
+    end
+
+    it 'returns 0.0 on emtpy clean inserted text' do
+      old_text = Text.new('Great old.')
+      new_text = Text.new('Great old. {{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/biased_impact_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BiasedImpact do
+  it { is_expected.to be_a Features::ImpactBase }
+
+  describe '#calculate' do
+    it 'returns the impact of biased words of the new revision text' do
+      # 1 vulgarism
+      old_text = Text.new('this is classic!')
+      # 3 vulgarism
+      new_text = Text.new('This is classic, legendary and amazing!')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 1.0 / (1.0 + 3.0)
+    end
+
+    it 'returns 0.5 on both no terms in text revisions' do
+      text = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: text)
+      new_rev = build(:new_revision, text: text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.5
+    end
+
+    it 'returns 0.0 on emtpy clean text of old revision' do
+      old_text = Text.new('{{speedy deletion}}')
+      new_text = Text.new('great')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+
+    it 'returns 1.0 on emtpy clean text of new revision' do
+      old_text = Text.new('great')
+      new_text = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 1.0
+    end
+  end
+end

data/spec/vandalism_detection/features/blanking_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::Blanking do
+  let(:blank_text) { 'a' * (Features::Blanking::BLANKING_THRESHOLD - 1) }
+
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    it 'returns 1.0 in case of full blanking the new revision' do
+      # full blanking means size < BLANKING_THRESHOLD.
+      old_rev = build(:old_revision, text: "#{blank_text} additional text")
+      new_rev = build(:new_revision, text: blank_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 1.0
+    end
+
+    it 'returns 0.0 in case of not full blanking the new revision' do
+      # not full blanking means size > BLANKING_THRESHOLD.
+      old_rev = build(:old_revision, text: "#{blank_text} additional text")
+      new_rev = build(:new_revision, text: "#{blank_text}a")
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+
+    it 'returns 0.0 if old revision is <= new revision' do
+      old_rev = build(:old_revision, text: blank_text)
+      new_rev = build(:new_revision, text: blank_text.next!)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/character_diversity_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::CharacterDiversity do
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    it 'returns the character diversity of the new inserted text' do
+      old_text = Text.new('text')
+      # 9 unique characters of total 14
+      new_text = Text.new('text [[aa ab cdeefg]]')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 14**(1.0 / 9)
+    end
+
+    it 'returns 0.0 if no text inserted' do
+      old_text = Text.new('deletion text')
+      new_text = Text.new('text')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/character_sequence_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::CharacterSequence do
+  it { is_expected.to be_a Features::Base }
+
+  describe '#calculate' do
+    it 'returns the number of the new revision’s longest character sequence' do
+      old_text = Text.new('a 666666')
+      new_text = Text.new("a 666666 4444ccc eefffff gggg g ''fffaffff''")
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 5
+    end
+
+    it 'returns 0 if no text was inserted' do
+      old_text = Text.new('a 666666 4444ccc eeeefffff gggg g')
+      new_text = Text.new('a 666666 ')
+
+      old_rev = build(:old_revision, text: old_text)
+      new_rev = build(:new_revision, text: new_text)
+
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 0
+    end
+  end
+end

data/spec/vandalism_detection/features/comment_bad_frequency_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::CommentBadFrequency do
+  it { is_expected.to be_a Features::FrequencyBase }
+
+  describe '#calculate' do
+    it 'returns the number of bad words in comment over all words' do
+      # total 11 words, 7 bad words
+      comment = Text.new('666 was 666 if 666 was 666 and guy are 666')
+
+      old_rev = build(:old_revision)
+      new_rev = build(:new_revision, comment: comment)
+      edit = build(:edit, old_revision: old_rev, new_revision: new_rev)
+
+      expect(subject.calculate(edit)).to eq 6.0 / 11.0
+    end
+
+    it 'returns 0.0 on emtpy clean text comment' do
+      comment = Text.new('{{speedy deletion}}')
+
+      old_rev = build(:old_revision)
+      new_rev = build(:new_revision, comment: comment)
+      edit = build(:edit, new_revision: new_rev, old_revision: old_rev)
+
+      expect(subject.calculate(edit)).to eq 0.0
+    end
+  end
+end