defender 0.1.1 → 0.2.0

data/spec/defender_spec.rb

@@ -1,124 +1,24 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Defender" do
+describe Defender do
   before(:each) do
-    @defender = Defender.new(:api_key => "validkey", :owner_url => "validurl")
+    FakeWeb.clean_registry
   end
 
-  it "should raise a StandardError if a method fails" do
-    lambda do
-      Defender.raise_if_error({
-        "status" => "fail",
-        "message" => "Failed!"
-       })
-    end.should raise_error(StandardError, "Failed!")
-  end
-  
-  it "should return the correct URL for any given action" do
-    @defender.instance_eval do
-      url("foobar")
-    end.should == "http://api.defensio.com/blog/#{Defender::API_VERSION}/foobar/validkey.yaml"
-  end
-  
-  it "should correctly identify a valid API key" do
-    @defender.stubs(:call_action).with("validate-key").returns(
-      {"status" => "success", "message" => ""}
-    )
-    @defender.valid_key?.should be_true
-  end
-  
-  it "should correctly identify an invalid API key" do
-    @defender.stubs(:call_action).with("validate-key").returns(
-      {"status" => "fail", "message" => "Invalid key"}
-    )
-    @defender.valid_key?.should be_false
-  end
-  
-  it "should correctly identify a spammy comment" do
-    @defender.
-      stubs(:call_action).
-      with('audit-comment', {
-        "user-ip" => "127.0.0.1",
-        "article-date" => Time.now.strftime("%Y/%m/%d"),
-        "comment-author" => "Henrik Hodne",
-        "comment-type" => "comment",
-        "test-force" => "spam,0.5000",
-      }).
-      returns(
-      {"signature" => "abc123", "spam" => true, "spaminess" => 0.5}
-    )
-    @defender.audit_comment(
-      :user_ip => "127.0.0.1",
-      :article_date => Time.now,
-      :comment_author => "Henrik Hodne",
-      :comment_type => "comment",
-      :test_force => "spam,0.5000"
-    ).spam?.should be_true
-  end
-  
-  it "should correctly identify a meaty comment" do
-    @defender.
-      stubs(:call_action).
-      with('audit-comment', {
-        "user-ip" => "127.0.0.1",
-        "article-date" => Time.now.strftime("%Y/%m/%d"),
-        "comment-author" => "Henrik Hodne",
-        "comment-type" => "comment",
-        "test-force" => "ham,0.1000",
-      }).
-      returns(
-      {"signature" => "abc123", "spam" => false, "spaminess" => 0.1}
-    )
-    @defender.audit_comment(
-      :user_ip => "127.0.0.1",
-      :article_date => Time.now,
-      :comment_author => "Henrik Hodne",
-      :comment_type => "comment",
-      :test_force => "ham,0.1000"
-    ).spam?.should be_false
-  end
-  
-  it "should correctly set the spaminess" do
-    @defender.
-      stubs(:call_action).
-      with('audit-comment', {
-        "user-ip" => "127.0.0.1",
-        "article-date" => Time.now.strftime("%Y/%m/%d"),
-        "comment-author" => "Henrik Hodne",
-        "comment-type" => "comment",
-        "test-force" => "spam,0.5000",
-      }).
-      returns(
-      {"signature" => "abc123", "spam" => true, "spaminess" => 0.5}
-    )
-    @defender.audit_comment(
-      :user_ip => "127.0.0.1",
-      :article_date => Time.now,
-      :comment_author => "Henrik Hodne",
-      :comment_type => "comment",
-      :test_force => "spam,0.5000"
-    ).spaminess.should == 0.5
-  end
-  
-  it "should fail without valid API credentials" do
-    @defender.
-      stubs(:call_action).
-      with('audit-comment', {
-        "user-ip" => "127.0.0.1",
-        "article-date" => Time.now.strftime("%Y/%m/%d"),
-        "comment-author" => "Henrik Hodne",
-        "comment-type" => "comment",
-        "test-force" => "ham,0.1000",
-      }).
-      raises(StandardError)
-    lambda {
-      d.audit_comment(
-        :user_ip => "127.0.0.1",
-        :article_date => Time.now,
-        :comment_author => "Henrik Hodne",
-        :comment_type => "comment",
-        :test_force => "ham,0.1000"
-      )
-    }.should raise_error(StandardError)
+  context "api keys" do
+    it "returns false when given an invalid API key" do
+      FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/foobar.json",
+                           :body => '{"defensio-result":{"status":"failed","message":"API key not found","api-version":"2.0","owner-url":""}}',
+                          :status => ['404', 'Not Found'])
+      Defender.api_key = "foobar"
+      Defender.check_api_key.should be_false
+    end
+
+    it "returns true when given a valid API key" do
+      FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/barbaz.json",
+                           :body => '{"defensio-result":{"status":"success","message":"","api-version":"2.0","owner-url":""}}')
+      Defender.api_key = "barbaz"
+      Defender.check_api_key.should be_true
+    end
   end
 end

data/spec/document_spec.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Defender::Document do
+  before(:each) do
+    FakeWeb.clean_registry
+  end
+
+  context "creating documents" do
+    it "should allow an innocent document to be posted when given only required options" do
+      FakeWeb.register_uri(:post, "http://api.defensio.com/2.0/users/foobar/documents.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"","signature":"baz",
+                                      "allow":true,"classification":"innocent","spaminess":0.1,
+                                      "profanity-match":false}}')
+      Defender.api_key = "foobar"
+      document = Defender::Document.new
+      document.content = "[innocent,0.1]"
+      document.type = :test
+      document.save
+
+      document.allow?.should be_true
+      document.classification.should == "innocent"
+      document.spaminess.should == 0.1
+      document.profane?.should be_false
+      document.signature.should == "baz"
+    end
+
+    it "marks an asynchronously requested document as pending" do
+      FakeWeb.register_uri(:post, "http://api.defensio.com/2.0/users/foobar/documents.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"pending","message":"","signature":"baz",
+                           "allow":null,"classification":null,"spaminess":null,"profanity-match":null}}')
+
+      Defender.api_key = "foobar"
+      document = Defender::Document.new
+      document.content = "[innocent,0.1]"
+      document.type = :test
+      document.save(true)
+
+      document.pending?.should be_true
+    end
+
+    it "should not allow a spammy document to be posted when given only required options" do
+      FakeWeb.register_uri(:post, "http://api.defensio.com/2.0/users/foobar/documents.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"","signature":"bar",
+                           "allow":false,"classification":"spam","spaminess":0.89,"profanity-match":false}}')
+
+      Defender.api_key = "foobar"
+      document = Defender::Document.new
+      document.content = "[spam,0.89]"
+      document.type = :test
+      document.save
+
+      document.allow?.should be_false
+      document.classification.should == "spam"
+      document.spaminess.should == 0.89
+      document.profane?.should be_false
+      document.signature.should == "bar"
+    end
+
+    it "accepts a string to parent-document-date" do
+      document = Defender::Document.new
+      document.parent_document_date = '1970-01-01'
+      document.attributes_hash['parent-document-date'].should == '1970-01-01'
+    end
+
+    it "accepts a Time to parent-document-date" do
+      time = Time.now
+      document = Defender::Document.new
+      document.parent_document_date = time
+      document.attributes_hash['parent-document-date'].should == time.strftime('%Y-%m-%d')
+    end
+
+    it "accepts a hash as headers" do
+      document = Defender::Document.new
+      document.http_headers = {"Foo" => "Bar", "Bar" => "Baz"}
+      document.attributes_hash['http-headers'].should == "Foo: Bar\nBar: Baz"
+    end
+
+    it "accepts an array as headers" do
+      document = Defender::Document.new
+      document.http_headers = ["Foo: Bar", "Bar: Baz"]
+      document.attributes_hash['http-headers'].should == "Foo: Bar\nBar: Baz"
+    end
+
+    it "returns false on server error" do
+      FakeWeb.register_uri(:post, "http://api.defensio.com/2.0/users/foobar/documents.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"failed","message":"Oopsies"}}',
+                           :status => ["500", "Server Error"])
+      Defender.api_key = "foobar"
+      document = Defender::Document.new
+      document.content = "[spam,0.89]"
+      document.type = :test
+      document.save.should be_false
+    end
+  end
+
+  context "finding documents" do
+    it "sets the attributes for a found object" do
+      FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/foobar/documents/baz.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"",
+                           "signature":"baz","allow":false,"classification":"spam","spaminess":0.89,"profanity-match":false}}')
+
+      Defender.api_key = "foobar"
+      document = Defender::Document.find("baz")
+      document.allow?.should be_false
+      document.classification.should == "spam"
+      document.spaminess.should == 0.89
+      document.profane?.should be_false
+      document.signature.should == "baz"
+    end
+
+    it "raises a StandardError on server error" do
+      FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/foobar/documents/baz.json",
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"failed","message":"oops"}}',
+                           :status => ["500", "Server Error"])
+
+      Defender.api_key = "foobar"
+      lambda { Defender::Document.find("baz") }.should raise_error(StandardError, "oops")
+    end
+  end
+
+  context "updating documents" do
+    it "only sets the allow attribute" do
+      FakeWeb.register_uri(:get, 'http://api.defensio.com/2.0/users/foobar/documents/baz.json',
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"",
+                           "signature":"baz","allow":false,"classification":"spam","spaminess":0.89,"profanity-match":false}}')
+      FakeWeb.register_uri(:put, 'http://api.defensio.com/2.0/users/foobar/documents/baz.json',
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"",
+                           "signature":"","allow":true,"classification":"spam","spaminess":0.89,"profanity-match":false"}}')
+
+      Defender.api_key = 'foobar'
+      document = Defender::Document.find('baz')
+      document.allow = true
+      oldcontent = document.content
+      lambda { document.content = 'foobar!' }.should raise_error(NameError)
+      document.save.should be_true
+      document.content.should == oldcontent
+      document.content.should_not == 'foobar!'
+      document.allow.should be_true
+    end
+
+    it 'returns false when the server encounts an error' do
+      FakeWeb.register_uri(:get, 'http://api.defensio.com/2.0/users/foobar/documents/baz.json',
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"",
+                           "signature":"baz","allow":false,"classification":"spam","spaminess":0.89,"profanity-match":false}}')
+      FakeWeb.register_uri(:put, 'http://api.defensio.com/2.0/users/foobar/documents/baz.json',
+                           :body => '{"defensio-result":{"api-version":"2.0","status":"failed","message":"UTTER FAIL!"}}',
+                           :status => ['500', 'Server Error'])
+
+      Defender.api_key = 'foobar'
+      document = Defender::Document.find('baz')
+      document.allow = true
+      document.save.should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,14 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+
 require 'defender'
 require 'spec'
 require 'spec/autorun'
-require 'mocha'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
 
 Spec::Runner.configure do |config|
-  
 end

data/spec/statistics_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Defender::Statistics do
+  before(:each) do
+    FakeWeb.clean_registry
+  end
+
+  it "retrieves basic statistics from the server" do
+    FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/foobar/basic-stats.json",
+                         :body => '{"defensio-result":{"api-version":"2.0","status":"success","message":"",
+                         "false-negatives":42,"false-positives":1,"learning":true,
+                         "learning-status":"foo!","legitimate":{"total":15},
+                         "recent-accuracy":0.9525,"unwanted":{"malicious":2,"spam":5,
+                         "total":7}}}')
+
+    Defender.api_key = "foobar"
+    statistics = Defender::Statistics.new
+    statistics.api_version.should == "2.0"
+    statistics.false_negatives.should == 42
+    statistics.false_positives.should == 1
+    statistics.learning.should be_true
+    statistics.legitimate_total.should == 15
+    statistics.recent_accuracy.should == 0.9525
+    statistics.unwanted_malicious.should == 2
+    statistics.unwanted_spam.should == 5
+    statistics.unwanted_total.should == 7
+  end
+
+  it "raises a StandardError if the server fails" do
+    FakeWeb.register_uri(:get, "http://api.defensio.com/2.0/users/foobar/basic-stats.json",
+                         :body => '{"defensio-result":{"api-version":"2.0","status":"failed","message":"Oops"}}',
+                         :status => ["500", "Server Error"])
+
+    Defender.api_key = "foobar"
+    lambda { Defender::Statistics.new }.should raise_error(StandardError, "Oops")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: defender
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Henrik Hodne
@@ -9,16 +9,26 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-09 00:00:00 +01:00
+date: 2010-01-20 00:00:00 +01:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.4.3
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         version: 1.2.9
     version: 
@@ -28,19 +38,19 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.4.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: fakeweb
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.8
+        version: 1.2.7
     version: 
 description: A wrapper of the Defensio spam filtering service.
 email: henrik.hodne@binaryhex.com
@@ -58,10 +68,15 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- defender.gemspec
 - lib/defender.rb
+- lib/defender/document.rb
+- lib/defender/statistics.rb
 - spec/defender_spec.rb
+- spec/document_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/statistics_spec.rb
 has_rdoc: true
 homepage: http://github.com/dvyjones/defender
 licenses: []
@@ -92,4 +107,6 @@ specification_version: 3
 summary: Ruby API wrapper for Defensio
 test_files: 
 - spec/spec_helper.rb
+- spec/document_spec.rb
 - spec/defender_spec.rb
+- spec/statistics_spec.rb