cerberus 0.6 → 0.7

data/lib/vendor/twitter/spec/twitter/ext/stdlib_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Hash, "#to_http_str" do
+  before(:each) do
+    @http_params = {:id => 'otherlogin', :since_id => 3953743, :full_name => 'Lucy Cross'}
+    @id_regexp = Regexp.new("id=#{CGI.escape(@http_params[:id].to_s)}")
+    @since_id_regexp = Regexp.new("since_id=#{CGI.escape(@http_params[:since_id].to_s)}")
+    @full_name_regexp = Regexp.new("full_name=Lucy\\+Cross")
+  end
+
+  it "should generate expected URL encoded string" do
+    http_str = @http_params.to_http_str
+    http_str.should match(@id_regexp)
+    http_str.should match(@since_id_regexp)
+    http_str.should match(@full_name_regexp)
+  end
+
+  after(:each) do
+    @http_params = nil
+    @id_kv_str, @since_id_kv_str, @full_name_kv_str = nil
+  end
+end
+
+describe Time, "#to_s" do
+  before(:each) do
+    @time = Time.now
+    @expected_string = @time.rfc2822
+  end
+
+  it "should output RFC2822 compliant string" do
+    time_string = @time.to_s
+    time_string.should eql(@expected_string)
+  end
+
+  it "should respond to #old_to_s" do
+    @time.should respond_to(:old_to_s)
+  end
+
+  after(:each) do
+    nilize(@time, @expected_string)
+  end
+end
+
+# TODO: figure out how to stub the gem method to do what we want rather than this monstrousity.  It is dependent on the system installation, which is always a bad thing.  For now it will do so we can ship with 100% C0 coverage.
+describe Kernel, "#gem_present?" do
+  before(:each) do
+    @present_gem = "rake"
+    @uninstalled_gem = "uninstalled-gem-crap"
+  end
+
+  it "should return true when a gem isn't present on system" do
+    gem_present?(@present_gem).should eql(true)
+  end
+
+  it "should return false when a gem isn't present on system" do
+    gem_present?(@uninstalled_gem).should eql(false)
+  end
+end
+

data/lib/vendor/twitter/spec/twitter/extras_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Twitter::Client, "#featured(:users)" do
+  before(:each) do
+    @twitter = client_context
+    @uris = Twitter::Client.class_eval("@@FEATURED_URIS")
+    @request = mas_net_http_get(:basic_auth => nil)
+    @response = mas_net_http_response(:success)
+    @connection = mas_net_http(@response)
+    Net::HTTP.stub!(:new).and_return(@connection)
+    @users = [
+      Twitter::User.new(:screen_name => 'twitter4r'),
+      Twitter::User.new(:screen_name => 'dictionary'),
+    ]
+    Twitter::User.stub!(:unmarshal).and_return(@users)
+  end
+
+  it "should create expected HTTP GET request" do
+    @twitter.should_receive(:create_http_get_request).with(@uris[:users]).and_return(@request)
+    @twitter.featured(:users)
+  end
+
+  it "should bless Twitter::User models returned" do
+    @twitter.should_receive(:bless_models).with(@users).and_return(@users)
+    @twitter.featured(:users)
+  end
+
+  after(:each) do
+    nilize(@twitter, @uris, @request, @response, @connection)
+  end
+end
+
+describe Twitter::User, ".featured" do
+  before(:each) do
+    @twitter = client_context
+  end
+
+  it "should delegate #featured(:users) message to given client context" do
+    @twitter.should_receive(:featured).with(:users).and_return([])
+    Twitter::User.featured(@twitter)
+  end
+
+  after(:each) do
+    nilize(@twitter)
+  end
+end

data/lib/vendor/twitter/spec/twitter/meta_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+def glob_files(*path_elements)
+  Dir.glob(File.join(*path_elements))
+end
+
+def load_erb_yaml(path, context)
+  ryaml = ERB.new(File.read(path), 0)
+  YAML.load(ryaml.result(context))
+end
+
+module ERBMetaMixin
+  # Needed to make the YAML load work...
+  def project_files
+    glob_files(@root_dir, 'lib', '**/*.rb')
+  end
+
+  # Needed to make the YAML load work...
+  def spec_files
+    glob_files(@root_dir, 'spec', '**/*_spec.rb')
+  end
+end
+
+describe "Twitter::Meta cache policy" do
+  include ERBMetaMixin
+  before(:each) do
+    @root_dir = project_root_dir
+    @meta = Twitter::Meta.new(@root_dir)
+    @expected_pkg_info = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+
+  it "should store value returned from project_files in @project_files after first glob" do
+    @meta.instance_eval("@project_files").should eql(nil)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should eql(@expected_project_files)
+    @meta.project_files
+    @meta.instance_eval("@project_files").should eql(@expected_project_files)
+  end
+
+  it "should store value returned from spec_files in @spec_files after first glob" do
+    @meta.instance_eval("@spec_files").should eql(nil)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should eql(@expected_spec_files)
+    @meta.spec_files
+    @meta.instance_eval("@spec_files").should eql(@expected_spec_files)
+  end
+end
+
+describe "Twitter::Meta" do
+  include ERBMetaMixin
+  before(:each) do
+    @root_dir = project_root_dir
+    @meta = Twitter::Meta.new(@root_dir)
+    @expected_yaml_hash = load_erb_yaml(File.join(@root_dir, 'pkg-info.yml'), binding)
+    @expected_project_files = project_files
+    @expected_spec_files = spec_files
+  end
+
+  it "should load and return YAML file into Hash object upon #pkg_info call" do
+    yaml_hash = @meta.pkg_info
+    yaml_hash.should.eql? @expected_yaml_hash
+  end
+
+  it "should return the embedded hash responding to key 'spec' of #pkg_info call upon #spec_info call" do
+    yaml_hash = @meta.spec_info
+    yaml_hash.should.eql? @expected_yaml_hash['spec']
+  end
+
+  it "should return list of files matching ROOT_DIR/lib/**/*.rb upon #project_files call" do
+    project_files = @meta.project_files
+    project_files.should.eql? @expected_project_files
+  end
+
+  it "should return list of files matching ROOT_DIR/spec/**/*.rb upon #spec_files call" do
+    spec_files = @meta.spec_files
+    spec_files.should.eql? @expected_spec_files
+  end
+
+  it "should return Gem specification based on YAML file contents and #project_files and #spec_files return values" do
+    spec = @meta.gem_spec
+    expected_spec_hash = @expected_yaml_hash['spec']
+    expected_spec_hash.each do |key, val|
+      unless val.is_a?(Hash)
+        spec.send(key).should.eql? expected_spec_hash[key]
+      end
+    end
+  end
+end

data/lib/vendor/twitter/spec/twitter/model_spec.rb

@@ -0,0 +1,508 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+module Test
+  class Model
+    include Twitter::ModelMixin
+  end
+end
+
+describe Twitter::Status, "unmarshaling" do
+  before(:each) do
+    @json_hash = { "text" => "Thinking Zipcar is lame...",
+                   "id" => 46672912,
+                   "user" => {"name" => "Angie",
+                              "description" => "TV junkie...",
+                              "location" => "NoVA",
+                              "profile_image_url" => "http:\/\/assets0.twitter.com\/system\/user\/profile_image\/5483072\/normal\/eye.jpg?1177462492",
+                              "url" => nil,
+                              "id" => 5483072,
+                              "protected" => false,
+                              "screen_name" => "ang_410"},
+                   "created_at" => "Wed May 02 03:04:54 +0000 2007"}
+    @user = Twitter::User.new @json_hash["user"]
+    @status = Twitter::Status.new @json_hash
+    @status.user = @user
+  end
+
+  it "should respond to unmarshal class method" do
+    Twitter::Status.should respond_to(:unmarshal)
+  end
+
+  it "should return expected Twitter::Status object for singular case" do
+    status = Twitter::Status.unmarshal(JSON.unparse(@json_hash))
+    status.should_not be(nil)
+    status.should eql(@status)
+  end
+
+  it "should return expected array of Twitter::Status objects for plural case" do
+    statuses = Twitter::Status.unmarshal(JSON.unparse([@json_hash]))
+    statuses.should_not be(nil)
+    statuses.should have(1).entries
+    statuses.first.should eql(@status)
+  end
+end
+
+describe Twitter::User, "unmarshaling" do
+  before(:each) do
+    @json_hash = { "name" => "Lucy Snowe",
+                   "description" => "School Mistress Entrepreneur",
+                   "location" => "Villette",
+                   "url" => "http://villetteschoolforgirls.com",
+                   "id" => 859303,
+                   "protected" => true,
+                   "screen_name" => "LucyDominatrix", }
+    @user = Twitter::User.new @json_hash
+  end
+
+  it "should respond to unmarshal class method" do
+    Twitter::User.should respond_to(:unmarshal)
+  end
+
+  it "should return expected arry of Twitter::User objects for plural case" do
+    users = Twitter::User.unmarshal(JSON.unparse([@json_hash]))
+    users.should have(1).entries
+    users.first.should eql(@user)
+  end
+
+  it "should return expected Twitter::User object for singular case" do
+    user = Twitter::User.unmarshal(JSON.unparse(@json_hash))
+    user.should_not be(nil)
+    user.should eql(@user)
+  end
+end
+
+describe "Twitter::ModelMixin#to_hash" do
+	before(:all) do
+    class Model
+	include Twitter::ModelMixin
+	@@ATTRIBUTES = [:id, :name, :value, :unused_attr]
+	attr_accessor *@@ATTRIBUTES
+	def self.attributes; @@ATTRIBUTES; end
+    end
+
+    class Hash
+	def eql?(other)
+		return false unless other # trivial nil case.
+		return false unless self.keys.eql?(other.keys)
+		self.each do |key,val|
+			return false unless self[key].eql?(other[key])
+		end
+		true
+	end
+    end
+	end
+
+  before(:each) do
+    @attributes = {:id => 14, :name => 'State', :value => 'Illinois'}
+    @model = Model.new(@attributes)
+  end
+
+  it "should return expected hash representation of given model object" do
+    @model.to_hash.should eql(@attributes)
+  end
+
+  after(:each) do
+    nilize(@attributes, @model)
+  end
+end
+
+describe Twitter::User, ".find" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config 'config/twitter.yml'
+    @id = 2423423
+    @screen_name = 'ascreenname'
+    @expected_user = Twitter::User.new(:id => @id, :screen_name => @screen_name)
+  end
+
+  it "should invoke given Twitter::Client's #user method with expected arguments" do
+		# case where id => @id
+    @twitter.should_receive(:user).with(@id).and_return(@expected_user)
+    user = Twitter::User.find(@id, @twitter)
+    user.should eql(@expected_user)
+
+    # case where id => @screen_name, which is also valid
+    @twitter.should_receive(:user).with(@screen_name).and_return(@expected_user)
+    user = Twitter::User.find(@screen_name, @twitter)
+    user.should eql(@expected_user)
+  end
+
+  after(:each) do
+    nilize(@twitter, @id, @screen_name, @expected_user)
+  end
+end
+
+describe Twitter::Status, ".find" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config 'config/twitter.yml'
+    @id = 9439843
+    @text = 'My crummy status message'
+    @user = Twitter::User.new(:id => @id, :screen_name => @screen_name)
+    @expected_status = Twitter::Status.new(:id => @id, :text => @text, :user => @user)
+  end
+
+  it "should invoke given Twitter::Client's #status method with expected arguments" do
+    @twitter.should_receive(:status).with(:get, @id).and_return(@expected_status)
+    status = Twitter::Status.find(@id, @twitter)
+    status.should eql(@expected_status)
+  end
+
+  after(:each) do
+    nilize(@twitter, @id, @text, @user, @expected_status)
+  end
+end
+
+describe Test::Model, "#bless" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config('config/twitter.yml')
+    @model = Test::Model.new
+  end
+
+  it "should delegate to #basic_bless" do
+    @model.should_receive(:basic_bless).and_return(@twitter)
+    @model.bless(@twitter)
+  end
+
+  it "should set client attribute of self" do
+    @model.should_receive(:client=).once
+    @model.bless(@twitter)
+  end
+
+  after(:each) do
+    nilize(@model, @twitter)
+  end
+end
+
+describe Twitter::User, "#is_me?" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config('config/twitter.yml')
+    @user_not_me = Twitter::User.new(:screen_name => 'notmylogin')
+    @user_me = Twitter::User.new(:screen_name => @twitter.instance_eval("@login"))
+    @user_not_me.bless(@twitter)
+    @user_me.bless(@twitter)
+  end
+
+  it "should return true when Twitter::User object represents authenticated user of client context" do
+    @user_me.is_me?.should be_true
+  end
+
+  it "should return false when Twitter::User object does not represent authenticated user of client context" do
+    @user_not_me.is_me?.should be_false
+  end
+
+  after(:each) do
+    nilize(@twitter, @user_not_me, @user_me)
+  end
+end
+
+describe Twitter::User, "#friends" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config('config/twitter.yml')
+    @id = 5701682
+    @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
+    @user.bless(@twitter)
+  end
+
+  it "should delegate to @client.user(@id, :friends)" do
+    @twitter.should_receive(:user).with(@id, :friends)
+    @user.friends
+  end
+
+  after(:each) do
+    nilize(@twitter, @id, @user)
+  end
+end
+
+describe Twitter::User, "#followers" do
+  before(:each) do
+    @twitter = Twitter::Client.from_config('config/twitter.yml')
+    @id = 5701682
+    @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
+    @user.bless(@twitter)
+  end
+
+  it "should delegate to @client.my(:followers)" do
+    @twitter.should_receive(:my).with(:followers, {})
+    @user.followers
+  end
+
+  after(:each) do
+    nilize(@twitter, @id, @user)
+  end
+end
+
+describe Test::Model, "#to_i" do
+  before(:each) do
+	@id = 234324285
+	class Test::Model
+		attr_accessor :id
+	end
+    @model = Test::Model.new(:id => @id)
+  end
+
+  it "should return @id attribute" do
+    @model.to_i.should eql(@id)
+  end
+
+  after(:each) do
+    nilize(@model, @id)
+  end
+end
+
+describe Test::Model, "#to_s" do
+  before(:each) do
+	class Test::Model
+		attr_accessor :text
+	end
+	@text = 'Some text for the message body here'
+    @model = Test::Model.new(:text => @text)
+  end
+
+  it "should return expected text when a @text attribute exists for the model" do
+    @model.to_s.should eql(@text)
+  end
+
+  after(:each) do
+    nilize(@model)
+  end
+end
+
+describe Twitter::Message, ".find" do
+  it "should raise NotImplementedError due to Twitter (as opposed to Twitter4R) API limitation" do
+    lambda {
+	Twitter::Message.find(123, nil)
+    }.should raise_error(NotImplementedError)
+  end
+end
+
+describe Twitter::Status, ".create" do
+  before(:each) do
+    @twitter = client_context
+    @text = 'My status update'
+    @status = Twitter::Status.new(:text => @text, :client => @twitter)
+  end
+
+  it "should invoke #status(:post, text) on client context given" do
+    @twitter.should_receive(:status).with(:post, @text).and_return(@status)
+    Twitter::Status.create(:text => @text, :client => @twitter)
+  end
+
+  it "should raise an ArgumentError when no client is given in params" do
+    lambda {
+	Twitter::Status.create(:text => @text)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError when no text is given in params" do
+	@twitter.should_receive(:is_a?).with(Twitter::Client)
+    lambda {
+	Twitter::Status.create(:client => @twitter)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError when text given in params is not a String" do
+    lambda {
+	Twitter::Status.create(:client => @twitter, :text => 234493)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError when client context given in params is not a Twitter::Client object" do
+    lambda {
+	Twitter::Status.create(:client => 'a string instead of a Twitter::Client', :text => @text)
+    }.should raise_error(ArgumentError)
+  end
+
+  after(:each) do
+    nilize(@twitter, @text, @status)
+  end
+end
+
+describe Twitter::Message, ".create" do
+  before(:each) do
+    @twitter = client_context
+    @text = 'Just between you and I, Lantana and Gosford Park are two of my favorite movies'
+    @recipient = Twitter::User.new(:id => 234958)
+    @message = Twitter::Message.new(:text => @text, :recipient => @recipient)
+  end
+
+  it "should invoke #message(:post, text, recipient) on client context given" do
+    @twitter.should_receive(:message).with(:post, @text, @recipient).and_return(@message)
+    Twitter::Message.create(:client => @twitter, :text => @text, :recipient => @recipient)
+  end
+
+  it "should raise an ArgumentError if no client context is given in params" do
+    lambda {
+	Twitter::Message.create(:text => @text, :recipient => @recipient)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError if client conext given in params is not a Twitter::Client object" do
+    lambda {
+	Twitter::Message.create(
+		:client => 3.14159,
+		:text => @text,
+		:recipient => @recipient)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError if no text is given in params" do
+	@twitter.should_receive(:is_a?).with(Twitter::Client)
+    lambda {
+	Twitter::Message.create(
+		:client => @twitter,
+		:recipient => @recipient)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError if text given in params is not a String" do
+    @twitter.should_receive(:is_a?).with(Twitter::Client)
+    lambda {
+	Twitter::Message.create(
+		:client => @twitter,
+		:text => Object.new,
+		:recipient => @recipient)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError if no recipient is given in params" do
+    @text.should_receive(:is_a?).with(String)
+    lambda {
+	Twitter::Message.create(
+		:client => @twitter,
+		:text => @text)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should raise an ArgumentError if recipient given in params is not a Twitter::User, Integer or String object" do
+    @text.should_receive(:is_a?).with(String)
+    lambda {
+	Twitter::Message.create(
+		:client => @twitter,
+		:text => @text,
+		:recipient => 3.14159)
+    }.should raise_error(ArgumentError)
+  end
+
+  after(:each) do
+    nilize(@twitter, @text, @recipient, @message)
+  end
+end
+
+describe Twitter::User, "#befriend" do
+  before(:each) do
+    @twitter = client_context
+    @user = Twitter::User.new(
+	:id => 1234,
+	:screen_name => 'mylogin',
+	:client => @twitter)
+    @friend = Twitter::User.new(
+	:id => 5678,
+	:screen_name => 'friend',
+	:client => @twitter)
+  end
+
+  it "should invoke #friend(:add, user) on client context" do
+    @twitter.should_receive(:friend).with(:add, @friend).and_return(@friend)
+    @user.befriend(@friend)
+  end
+
+  after(:each) do
+    nilize(@twitter, @user, @friend)
+  end
+end
+
+describe Twitter::User, "#defriend" do
+  before(:each) do
+    @twitter = client_context
+    @user = Twitter::User.new(
+	:id => 1234,
+	:screen_name => 'mylogin',
+	:client => @twitter)
+    @friend = Twitter::User.new(
+	:id => 5678,
+	:screen_name => 'friend',
+	:client => @twitter)
+  end
+
+  it "should invoke #friend(:remove, user) on client context" do
+    @twitter.should_receive(:friend).with(:remove, @friend).and_return(@friend)
+    @user.defriend(@friend)
+  end
+
+  after(:each) do
+    nilize(@twitter, @user, @friend)
+  end
+end
+
+describe Twitter::Status, "#reply?" do
+  before(:each) do
+    @status = Twitter::Status.new(
+      :id => 123456789,
+      :text => "Wazzup?",
+      :user => mock(Twitter::User)
+    )
+    @reply = Twitter::Status.new(
+      :text => "No much bro.  You?",
+      :user => mock(Twitter::User),
+      :in_reply_to_status_id => @status.id
+    )
+  end
+
+  it "should return false for the original status" do
+    @status.reply?.should be(false)
+  end
+
+  it "should return true for the reply to the original status" do
+    @reply.reply?.should be(true)
+  end
+end
+
+describe Twitter::Status, "#reply(status_text)" do
+  before(:each) do
+    @twitter = client_context
+    @status = Twitter::Status.new(
+        :id => 1234,
+        :text => "The status text",
+        :client => @twitter)
+    @reply_text = "Reply text goes here"
+    @reply_status = Twitter::Status.new()
+  end
+
+  it "should invoke #status(:reply, :status => ..., :in_reply_to_status_id => ...) on client context" do
+    @twitter.should_receive(:status).with(:reply, :status => @reply_text, :in_reply_to_status_id => @status.id).and_return(@reply_status)
+    @status.reply(@reply_text)
+  end
+
+  after(:each) do
+    nilize(@twitter, @status)
+  end
+end
+
+describe Twitter::Status, "#to_s" do
+  before(:each) do
+    @text = 'Aloha'
+    @status = Twitter::Status.new(:text => @text)
+  end
+
+  it "should render text attribute" do
+    @status.to_s.should be(@text)
+  end
+
+  after(:each) do
+    nilize(@text, @status)
+  end
+end
+
+describe Twitter::Message, "#to_s" do
+  before(:each) do
+	  @text = 'Aloha'
+    @message = Twitter::Message.new(:text => @text)
+  end
+
+  it "should render text attribute" do
+    @message.to_s.should be(@text)
+  end
+
+  after(:each) do
+    nilize(@text, @message)
+  end
+end