bcardarella-deepthroat 0.3.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Brian Cardarella
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,7 @@
+deepthroat==========
+Description goes here.
+
+COPYRIGHT
+=========
+
+Copyright (c) 2008 Brian Cardarella. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "deepthroat"
+    s.summary = %Q{TODO}
+    s.email = "bcardarella@gmail.com"
+    s.homepage = "http://github.com/bcardarella/deepthroat"
+    s.description = "TODO"
+    s.authors = ["Brian Cardarella"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'deepthroat'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.verbose = true
+  end
+rescue LoadError
+  puts "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+end
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 3
+:patch: 0

data/lib/deepthroat/base.rb

@@ -0,0 +1,41 @@
+module DeepThroat
+  class Base
+    include HTTParty
+    include HappyMapper
+    
+    CYCLES = [2006, 2008]
+    
+    base_uri "http://www.opensecrets.org/api"
+    
+    def self.find(attributes = {})
+      raise DeepThroat::NoCIDError unless attributes[:cid]
+      parse(get_xml(attributes))[0]
+    end
+    
+    def self.get_xml(attributes = {})
+      attributes.merge!({ :apikey => DeepThroat.api_key })
+                  
+      attributes.delete_if { |key, value| value.nil? }
+
+      if attributes[:cycle].to_i != 0 and not CYCLES.include?(attributes[:cycle].to_i)
+        raise DeepThroat::InvalidOrMissing::CycleError, "Valid Cycles are: #{ CYCLES.join(", ") }" 
+      end
+      
+      handle_response(get("/", :query => attributes), attributes)
+    end
+    
+    def self.handle_response(response, attributes = {})
+      case response.code.to_i
+      when 200 then response.body
+      when 400..499
+        case response.body
+        when /key does not have access to this method/ then raise DeepThroat::InvalidOrMissing::ApiKeyError, "#{attributes[:apikey]} is not valid API Key"
+        when /Invalid CID/ then raise DeepThroat::InvalidOrMissing::CIDError, "#{attributes[:cid]} is not valid CID"
+        when /Invalid Year|Cycle/ then raise DeepThroat::InvalidOrMissing::CycleError, "Valid Cycles are: #{ CYCLES.join(", ") }"
+        else ; raise "Something unexpected happened: #{response.body}"
+        end
+      else ; raise "Something unexpected happened: #{response.body}"
+      end
+    end
+  end
+end

data/lib/deepthroat/contributions.rb

@@ -0,0 +1,29 @@
+module DeepThroat
+  
+  class Contributions < Base
+    include HappyMapper
+    
+    class Contributor
+      include HappyMapper
+
+      tag "contributor"
+      attribute :organization, String, :tag => "org_name"
+      attribute :total, Integer
+    end
+    
+    def self.find(attributes = {})
+      super(attributes.merge({:method => "candContrib"}))
+    end
+
+    attr_accessor :cid, :cycle, :xml, :details
+    
+    tag "contributors"
+    attribute :cid, String
+    attribute :cycle, Integer
+    attribute :name, String, :tag => "cand_name"
+    attribute :origin, String
+    attribute :source, String
+    has_many :contributors, Contributor
+    
+  end
+end

data/lib/deepthroat/industries.rb

@@ -0,0 +1,31 @@
+module DeepThroat
+  
+  class Industries < Base
+    include HappyMapper
+    
+    class Industry
+      include HappyMapper
+
+      tag "industry"
+      attribute :industry, String, :tag => "industry_name"
+      attribute :indivs, Integer
+      attribute :pacs, Integer
+      attribute :total, Integer
+    end
+    
+    def self.find(attributes = {})
+      super(attributes.merge({:method => "candIndustry"}))
+    end
+
+    attr_accessor :cid, :cycle, :xml, :details
+    
+    tag "industries"
+    attribute :cid, String
+    attribute :cycle, Integer
+    attribute :name, String, :tag => "cand_name"
+    attribute :origin, String
+    attribute :source, String
+    has_many :industries, Industry
+    
+  end
+end

data/lib/deepthroat/industry.rb

@@ -0,0 +1,35 @@
+module DeepThroat
+  
+  module InvalidOrMissing
+    class IndustryCodeError < StandardError; end
+  end
+  
+  class Industry < Base
+    include HappyMapper
+    
+    def self.find(attributes = {})
+      unless attributes.include?(:ind)
+        raise DeepThroat::InvalidOrMissing::IndustryCodeError, "Please pass a valid industry code - :ind => 'code'"
+      end
+      
+      super(attributes.merge({:method => "CandIndByInd"}))
+    end
+
+    attr_accessor :cid, :cycle, :xml, :details
+    
+    tag "candIndus"
+    attribute :cid, String
+    attribute :cycle, Integer
+    attribute :name, String, :tag => "cand_name"
+    attribute :origin, String
+    attribute :source, String
+    attribute :industry, String
+    attribute :chamber, String
+    attribute :party, String
+    attribute :state, String
+    attribute :total, Integer
+    attribute :indivs, Integer
+    attribute :pacs, Integer
+    attribute :rank, Integer
+  end
+end

data/lib/deepthroat/summaries.rb

@@ -0,0 +1,28 @@
+module DeepThroat
+  
+  class Summaries < Base
+    include HappyMapper
+    
+    def self.find(attributes = {})
+      super(attributes.merge({:method => "candSummary"}))
+    end
+
+    attr_accessor :cid, :cycle, :xml, :details
+    
+    tag "summary"
+    attribute :cid, String
+    attribute :cycle, Integer
+    attribute :name, String, :tag => "cand_name"
+    attribute :origin, String
+    attribute :source, String
+    attribute :state, String
+    attribute :party, String
+    attribute :chamber, String
+    attribute :first_elected, String
+    attribute :next_election, String
+    attribute :total, Integer
+    attribute :spent, Integer
+    attribute :cash_on_hand, Integer
+    attribute :debt, Integer
+  end
+end

data/lib/deepthroat/top_sectors.rb

@@ -0,0 +1,34 @@
+module DeepThroat
+  
+  class TopSectors < Base
+    include HappyMapper
+    
+    class Sector
+      include HappyMapper
+
+      tag "sector"
+      attribute :sector, String, :tag => "sector_name"
+      attribute :sectorid, String
+      attribute :indivs, Integer
+      attribute :pacs, Integer
+      attribute :total, Integer
+      
+      
+    end
+    
+    def self.find(attributes = {})
+      super(attributes.merge({:method => "candSector"}))
+    end
+
+    attr_accessor :cid, :cycle, :xml, :details
+    
+    tag "sectors"
+    attribute :cid, String
+    attribute :cycle, Integer
+    attribute :name, String, :tag => "cand_name"
+    attribute :origin, String
+    attribute :source, String
+    has_many :sectors, Sector
+    
+  end
+end

data/lib/deepthroat.rb

@@ -0,0 +1,28 @@
+require 'happymapper'
+require 'httparty'
+require 'deepthroat/base'
+require 'deepthroat/contributions'
+require 'deepthroat/industries'
+require 'deepthroat/industry'
+require 'deepthroat/top_sectors'
+require 'deepthroat/summaries'
+
+
+module DeepThroat
+  def self.api_key
+    @api_key
+  end
+  
+  def self.api_key=(api_key)
+    @api_key = api_key
+  end
+  
+  class NoCIDError < StandardError; end
+  class NoCycleError < StandardError; end
+  
+  module InvalidOrMissing
+    class ApiKeyError < StandardError; end
+    class CIDError < StandardError; end
+    class CycleError < StandardError; end
+  end
+end

data/test/test_deepthroat.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DeepThroatTest < Test::Unit::TestCase
+  context "Class methods" do
+    context ".api_key=" do
+      setup { DeepThroat.api_key = "test" }
+      should "set the api_key" do
+        assert_equal "test", DeepThroat.api_key
+      end
+    end
+  end
+  
+  context "DeepThroat Errors" do
+    should "include NoCIDError" do
+      assert_nothing_raised do
+        DeepThroat::NoCIDError
+      end
+    end
+    
+    should "include NoCycleError" do
+      assert_nothing_raised do
+        DeepThroat::NoCycleError
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'test/unit'
+require 'rr'
+require 'shoulda'
+require 'fake_web'
+require 'ruby-debug'
+
+FakeWeb.allow_net_connect = false
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'deepthroat'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit unless included_modules.include?(RR::Adapters::TestUnit)
+  
+  def self.define_xml_fixture_methods
+    Dir.new("#{File.dirname(__FILE__)}/xml_samples").map { |file| file.gsub(/.xml/,"") if file =~ /.xml/ }.compact.each do |file|
+      define_method("#{file}_response") do
+        instance_eval("@#{file}_xml ||= File.read(\"#{File.dirname(__FILE__)}/xml_samples/#{file}.xml\")")
+      end
+
+      define_method("#{file}_xml") do
+        instance_eval("#{file}_response").match(/\<response\>.*$/)[0]
+      end
+    end
+  end
+  
+  FakeWeb.allow_net_connect = false
+  define_xml_fixture_methods
+
+  def web_faker(method, *params)
+    method = method.to_s
+    options = params[0]
+    
+    open_secrets_method = case method.split("_bad")[0]
+    when "contributions" then "candContrib"
+    when "industries" then "candIndustry"
+    when "industry" then "CandIndByInd"
+    when "top_sectors" then "candSector"
+    when "summaries" then "candSummary"
+    end
+    
+    if method =~ /bad/
+      method.sub!(/(\w+)_bad/,"").sub!(/^/,"bad")
+    end
+    
+    options.merge!({ :method => open_secrets_method })
+
+    FakeWeb.register_uri("http://www.opensecrets.org/api/?#{options.map {|key, value| "#{key}=#{value}"}.join("&")}", :response => send("#{method}_response"))
+  end
+end

data/test/unit/test_base.rb

@@ -0,0 +1,156 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestBase < Test::Unit::TestCase
+  context "Included Modules" do
+    should "have HTTParty" do
+      assert DeepThroat::Base.included_modules.include?(HTTParty)
+    end
+    
+    should "have HappyMapper" do
+      assert DeepThroat::Base.included_modules.include?(HappyMapper)
+    end
+  end
+  
+  context "Class Methods" do
+    context ".find" do
+      setup do
+        @xml_response = "<response></response>"
+        @attributes = {:cid => "TestCID"}
+      end
+      
+      should "respond to :find" do
+        assert DeepThroat::Base.respond_to? :find
+      end
+      
+      should "return an instance method" do
+        mock(DeepThroat::Base).parse(@xml_response) { [DeepThroat::Base.new] }
+        mock(DeepThroat::Base).get_xml(@attributes) { @xml_response }
+        assert DeepThroat::Base.find(@attributes).instance_of?(DeepThroat::Base)
+      end
+      
+      should "raise DeepThroat::NoCIDError if :cid is not passed" do
+        assert_raise DeepThroat::NoCIDError do
+          DeepThroat::Base.find
+        end
+      end
+    end
+    
+    context ".get_xml" do
+      setup do
+        @attributes = {:cid=>"TestCID"}
+      end
+      
+      should "return a String" do
+        stub(DeepThroat::Base).get("/", anything) { Object.new }
+        stub(DeepThroat::Base).handle_response(anything, anything) { String.new }
+        assert_kind_of String, DeepThroat::Base.get_xml(@attributes)
+      end
+      
+      should "call HTTParty's .get" do
+        mock(DeepThroat::Base).get("/", anything)
+        stub(DeepThroat::Base).handle_response(anything, anything)
+        DeepThroat::Base.get_xml(@attributes)
+      end
+      
+      should "handle the response" do
+        stub(DeepThroat::Base).get("/", anything) { Object.new }
+        mock(DeepThroat::Base).handle_response(anything, anything)
+        DeepThroat::Base.get_xml(@attributes)
+      end
+      
+      should "raise 'DeepThroat::InvalidOrMissing::CycleError' when asking for invalid CYCLE" do
+        stub(DeepThroat::Base).get("/", anything) { Object.new }
+        stub(DeepThroat::Base).handle_response(anything, anything)
+        
+        assert_raise DeepThroat::InvalidOrMissing::CycleError do
+          DeepThroat::Base.get_xml(@attributes.merge({:cycle => 2009}))
+        end        
+      end
+    end
+    
+    context ".handle_response(response)" do
+      context "200" do
+        should "return an XML string" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "200" }
+            body { "<response></response>" }
+          end
+        
+          assert_kind_of String, DeepThroat::Base.handle_response(mock_response)
+        end
+      end
+
+      context "400" do
+        should "raise 'DeepThroat::InvalidOrMissing::ApiKeyError'" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "400" }
+            body { "key does not have access to this method" }
+          end
+        
+          assert_raise DeepThroat::InvalidOrMissing::ApiKeyError do
+            DeepThroat::Base.handle_response(mock_response)
+          end
+        end
+      
+        should "raise 'DeepThroat::InvalidOrMissing::CIDError'" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "400" }
+            body { "Invalid CID" }
+          end
+        
+          assert_raise DeepThroat::InvalidOrMissing::CIDError do
+            DeepThroat::Base.handle_response(mock_response)
+          end
+        end
+
+        should "raise 'DeepThroat::InvalidOrMissing::CycleError'" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "400" }
+            body { "Invalid Year|Cycle" }
+          end
+        
+          assert_raise DeepThroat::InvalidOrMissing::CycleError do
+            DeepThroat::Base.handle_response(mock_response)
+          end
+        end
+
+        should "raise 'Something unexpected happened'" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "400" }
+            body.twice { "" }
+          end
+        
+          assert_raise RuntimeError, "Something unexpected happened" do
+            DeepThroat::Base.handle_response(mock_response)
+          end
+        end
+      end
+      
+      context "unknown code" do
+        should "raise 'Something unexpected happened'" do
+          mock_response = Object.new
+          mock(mock_response) do
+            code { "700" }
+            body { "" }
+          end
+        
+          assert_raise RuntimeError, "Something unexpected happened" do
+            DeepThroat::Base.handle_response(mock_response)
+          end
+        end
+      end
+    end
+    
+    context "HTTParty's .base_uri" do
+      should "equal 'http://www.opensecrets.org/api'" do
+        assert_equal "http://www.opensecrets.org/api", DeepThroat::Base.default_options[:base_uri]
+      end
+    end
+    
+  end
+end