wikipedia-vandalism_detection 0.0.1

data/spec/vandalism_detection/feature_calculator_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe  Wikipedia::VandalismDetection::FeatureCalculator do
+
+  it "raises NoFeaturesConfiguredError when no features are configured" do
+    configuration = Wikipedia::VandalismDetection::Configuration.send(:new)
+    configuration.instance_variable_set :@features, nil
+
+    use_configuration(configuration)
+
+    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
+    before do
+      @edit = build :edit
+    end
+
+    it { should respond_to :calculate_features_for }
+
+    it "takes an edit as parameter" do
+      expect { @calculator.calculate_features_for(@edit) }.not_to raise_error
+    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
+      @calculator.calculate_features_for(@edit).should be_an(Array)
+    end
+
+    it "returns the computed feature values" do
+      feature_values = @calculator.calculate_features_for(@edit)
+      expect( feature_values.select{ |value| value.is_a? Numeric }).to eq feature_values
+    end
+
+    it "returns the right number of feature values" do
+      expect(@calculator.calculate_features_for(@edit).count).to eq @calculator.used_features.count
+    end
+
+    it "uses the cleaned up text if revision contains a #REDIRECT" do
+      config = Wikipedia::VandalismDetection.configuration
+      redirect_text =  Wikipedia::VandalismDetection::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_redirect_1 =  Wikipedia::VandalismDetection::Edit.new(old_revision_redirect, new_revision)
+      edit_redirect_2 =  Wikipedia::VandalismDetection::Edit.new(old_revision, new_revision_redirect)
+
+      expect(@calculator.calculate_features_for(edit_redirect_1).count).to eq config.features.count
+      expect(@calculator.calculate_features_for(edit_redirect_2).count).to eq config.features.count
+    end
+
+    it "returns an array holding -1 for not extractable texts in either revision" do
+      configuration = Wikipedia::VandalismDetection::Configuration.instance
+      configuration.instance_variable_set :@features, ['all wordlists impact']
+
+      use_configuration(configuration)
+      calculator = Wikipedia::VandalismDetection::FeatureCalculator.new
+
+      unparsable_wiki_text = Wikipedia::VandalismDetection::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_1 =  Wikipedia::VandalismDetection::Edit.new(old_revision_unparsable, new_revision)
+      edit_2 =  Wikipedia::VandalismDetection::Edit.new(old_revision, new_revision_unparsable)
+
+      expect(calculator.calculate_features_for(edit_1)).to include Wikipedia::VandalismDetection::Features::MISSING_VALUE
+      expect(calculator.calculate_features_for(edit_2)).to include Wikipedia::VandalismDetection::Features::MISSING_VALUE
+    end
+  end
+
+  describe "#claculate_feature_for" do
+    before do
+      @edit = build :edit
+      @feature_name = "anonymity"
+      @random_number = rand(1000)
+      Wikipedia::VandalismDetection::Features::Anonymity.any_instance.stub(calculate: @random_number)
+    end
+
+    it { should 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
+    end
+
+    it "raises an error if called with wrong parameter type edit" do
+      revision = build :empty_revision
+      expect { @calculator.calculate_feature_for(revision, @feature_name) }.to raise_error ArgumentError
+    end
+
+    it "raises an error if called with wrong parameter type feature name" do
+      revision = build :empty_revision
+      expect { @calculator.calculate_feature_for(@edit, 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 { should respond_to :used_features }
+
+    it "returns an array of the features defined in the config feature.yml" do
+      expect(@calculator.used_features.sort).to eq Wikipedia::VandalismDetection.configuration.features.sort
+    end
+  end
+end

data/spec/vandalism_detection/features/all_wordlists_frequency_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::AllWordlistsFrequency do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::AllWordlistsFrequency.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::Features::FrequencyBase }
+
+  describe "#calculate" do
+
+    it "returns the inserted number of all wordlists words relative to all inserted words count" do
+      # inserted: total 8 words, 1 vulgarism, 1 biased, 2 pronouns = 4 bad
+      old_text = Wikipedia::VandalismDetection::Text.new 'Your old shit. '
+      new_text = Wikipedia::VandalismDetection::Text.new 'Your old shit. Fuck you great, you and all the others.'
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 4.0 / 8.0
+    end
+
+    it "returns 0.0 on empty clean inserted text" do
+      old_text = Wikipedia::VandalismDetection::Text.new 'Your old shit. '
+      new_text = Wikipedia::VandalismDetection::Text.new 'Your old shit. {{speedy deletion}}'
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/all_wordlists_impact_spec.rb

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

data/spec/vandalism_detection/features/anonymity_previous_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::AnonymityPrevious do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::AnonymityPrevious.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::Features::Base }
+
+  describe "#calculate" do
+
+    context "both contributors are given" do
+      it "return 1.0 in case of an registered previous editor" do
+        old_revision = build(:old_revision, contributor: 'Peter')
+        new_revision = build(:new_revision)
+        edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+        expect(@feature.calculate(edit)).to eq 1
+      end
+
+      it "returns 0.0 in case of an anonymous previous editor" do
+        old_revision = build(:old_revision, contributor: '137.163.16.199')
+        new_revision = build(:new_revision)
+        edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+        expect(@feature.calculate(edit)).to eq 0
+      end
+    end
+
+    context "previous contributor not given" do
+      it "requests the user from Wikipedia API and returns 1 in case of a registered previous editor" do
+        old_revision = build(:old_revision, id: '324557983', contributor: nil)
+        new_revision = build(:new_revision, id: '329962649', parent_id: '324557983', contributor: 'Tomaxer')
+        edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+        expect(@feature.calculate(edit)).to eq 1
+      end
+
+      it "requests the user from Wikipedia API and returns 0 in case of an anonymous previous editor" do # also same editor!
+        old_revision = build(:old_revision, id: '328774110', contributor: nil)
+        new_revision = build(:new_revision, id: '328774035', parent_id: '328774110')
+        edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+        expect(@feature.calculate(edit)).to eq 0
+      end
+
+      it "returns missing if old reivision is not available anymore" 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_revision = build(:old_revision, id: '325218985', contributor: nil)
+        new_revision = build(:new_revision, id: '326980599', parent_id: '325218985')
+        edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+        expect(@feature.calculate(edit)).to eq Wikipedia::VandalismDetection::Features::MISSING_VALUE
+      end
+    end
+  end
+end

data/spec/vandalism_detection/features/anonymity_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::Anonymity do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::Anonymity.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::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(@feature.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(@feature.calculate(@edit)).to eq 0
+    end
+  end
+end

data/spec/vandalism_detection/features/article_size_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::ArticleSize do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::ArticleSize.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::Features::Base }
+
+  describe "#calculate" do
+
+    it "returns the size of the edit's new revisions" do
+      old_revision_text = Wikipedia::VandalismDetection::Text.new '123'
+      new_revision_text = Wikipedia::VandalismDetection::Text.new '123 456789' # size 10 (with spaces)
+
+      old_revision = build(:old_revision, text: old_revision_text)
+      new_revision = build(:new_revision, text: new_revision_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 10
+    end
+
+    it "returns 0 if the edit's new revisions is empty" do
+      old_revision_text = Wikipedia::VandalismDetection::Text.new '123'
+      new_revision_text = Wikipedia::VandalismDetection::Text.new '' # size 0
+
+      old_revision = build(:old_revision, text: old_revision_text)
+      new_revision = build(:new_revision, text: new_revision_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 0
+    end
+  end
+end

data/spec/vandalism_detection/features/bad_frequency_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BadFrequency do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::BadFrequency.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::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 = Wikipedia::VandalismDetection::Text.new 'Old whatever.'
+      new_text = Wikipedia::VandalismDetection::Text.new "Old whatever. New ugly contents. Hi, gotta fun."
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 3.0 / 6.0
+    end
+
+    it "returns 0.0 on emtpy clean text revisions" do
+      old_text = Wikipedia::VandalismDetection::Text.new 'Old guy.'
+      new_text = Wikipedia::VandalismDetection::Text.new "Old guy. {{speedy deletion}}"
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 0.0
+    end
+  end
+end

data/spec/vandalism_detection/features/bad_impact_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Wikipedia::VandalismDetection::Features::BadImpact do
+
+  before do
+    @feature = Wikipedia::VandalismDetection::Features::BadImpact.new
+  end
+
+  it { should be_a Wikipedia::VandalismDetection::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 = Wikipedia::VandalismDetection::Text.new "Hi, old text 666, dont know"
+
+      # 4 bad words
+      new_text = Wikipedia::VandalismDetection::Text.new "Hi, new text dosent, whatever, guy"
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, old_revision: old_revision, new_revision: new_revision)
+
+      expect(@feature.calculate(edit)).to eq 3.0 / (3.0 + 4.0)
+    end
+
+    it "returns 0.5 on both no terms in text revisions" do
+      text = Wikipedia::VandalismDetection::Text.new "{{speedy deletion}}"
+
+      old_revision = build(:old_revision, text: text)
+      new_revision = build(:new_revision, text: text)
+      edit = build(:edit, new_revision: new_revision, old_revision: old_revision)
+
+      expect(@feature.calculate(edit)).to eq 0.5
+    end
+
+    it "returns 0.0 on emtpy clean text of old revision" do
+      old_text = Wikipedia::VandalismDetection::Text.new "{{speedy deletion}}"
+      new_text = Wikipedia::VandalismDetection::Text.new "Guy"
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_revision, old_revision: old_revision)
+
+      expect(@feature.calculate(edit)).to eq 0.0
+    end
+
+    it "returns 1.0 on emtpy clean text of new revision" do
+      old_text = Wikipedia::VandalismDetection::Text.new "Guy"
+      new_text = Wikipedia::VandalismDetection::Text.new "{{speedy deletion}}"
+
+      old_revision = build(:old_revision, text: old_text)
+      new_revision = build(:new_revision, text: new_text)
+      edit = build(:edit, new_revision: new_revision, old_revision: old_revision)
+
+      expect(@feature.calculate(edit)).to eq 1.0
+    end
+  end
+end

data/spec/vandalism_detection/features/base_spec.rb

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