spec/twitter/model_spec.rb

   1 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
   2
   3 module Test
   4   class Model
   5     include Twitter::ModelMixin
   6   end
   7 end
   8
   9 describe Twitter::Status, "unmarshaling" do
  10   before(:each) do
  11     @json_hash = { "text" => "Thinking Zipcar is lame...",
  12                    "id" => 46672912,
  13                    "user" => {"name" => "Angie",
  14                               "description" => "TV junkie...",
  15                               "location" => "NoVA",
  16                               "profile_image_url" => "http:\/\/assets0.twitter.com\/system\/user\/profile_image\/5483072\/normal\/eye.jpg?1177462492",
  17                               "url" => nil,
  18                               "id" => 5483072,
  19                               "protected" => false,
  20                               "screen_name" => "ang_410"},
  21                    "created_at" => "Wed May 02 03:04:54 +0000 2007"}
  22     @user = Twitter::User.new @json_hash["user"]
  23     @status = Twitter::Status.new @json_hash
  24     @status.user = @user
  25   end
  26
  27   it "should respond to unmarshal class method" do
  28     Twitter::Status.should respond_to(:unmarshal)
  29   end
  30
  31   it "should return expected Twitter::Status object for singular case" do
  32     status = Twitter::Status.unmarshal(JSON.unparse(@json_hash))
  33     status.should_not be(nil)
  34     status.should eql(@status)
  35   end
  36
  37   it "should return expected array of Twitter::Status objects for plural case" do
  38     statuses = Twitter::Status.unmarshal(JSON.unparse([@json_hash]))
  39     statuses.should_not be(nil)
  40     statuses.should have(1).entries
  41     statuses.first.should eql(@status)
  42   end
  43 end
  44
  45 describe Twitter::User, "unmarshaling" do
  46   before(:each) do
  47     @json_hash = { "name" => "Lucy Snowe",
  48                    "description" => "School Mistress Entrepreneur",
  49                    "location" => "Villette",
  50                    "url" => "http://villetteschoolforgirls.com",
  51                    "id" => 859303,
  52                    "protected" => true,
  53                    "screen_name" => "LucyDominatrix", }
  54     @user = Twitter::User.new @json_hash
  55   end
  56
  57   it "should respond to unmarshal class method" do
  58     Twitter::User.should respond_to(:unmarshal)
  59   end
  60
  61   it "should return expected arry of Twitter::User objects for plural case" do
  62     users = Twitter::User.unmarshal(JSON.unparse([@json_hash]))
  63     users.should have(1).entries
  64     users.first.should eql(@user)
  65   end
  66
  67   it "should return expected Twitter::User object for singular case" do
  68     user = Twitter::User.unmarshal(JSON.unparse(@json_hash))
  69     user.should_not be(nil)
  70     user.should eql(@user)
  71   end
  72 end
  73
  74 describe "Twitter::ModelMixin#to_hash" do
  75         before(:all) do
  76     class Model
  77         include Twitter::ModelMixin
  78         @@ATTRIBUTES = [:id, :name, :value, :unused_attr]
  79         attr_accessor *@@ATTRIBUTES
  80         def self.attributes; @@ATTRIBUTES; end
  81     end
  82
  83     class Hash
  84         def eql?(other)
  85                 return false unless other # trivial nil case.
  86                 return false unless self.keys.eql?(other.keys)
  87                 self.each do |key,val|
  88                         return false unless self[key].eql?(other[key])
  89                 end
  90                 true
  91         end
  92     end
  93         end
  94
  95   before(:each) do
  96     @attributes = {:id => 14, :name => 'State', :value => 'Illinois'}
  97     @model = Model.new(@attributes)
  98   end
  99
 100   it "should return expected hash representation of given model object" do
 101     @model.to_hash.should eql(@attributes)
 102   end
 103
 104   after(:each) do
 105     nilize(@attributes, @model)
 106   end
 107 end
 108
 109 describe Twitter::User, ".find" do
 110   before(:each) do
 111     @twitter = Twitter::Client.from_config 'config/twitter.yml'
 112     @id = 2423423
 113     @screen_name = 'ascreenname'
 114     @expected_user = Twitter::User.new(:id => @id, :screen_name => @screen_name)
 115   end
 116
 117   it "should invoke given Twitter::Client's #user method with expected arguments" do
 118                 # case where id => @id
 119     @twitter.should_receive(:user).with(@id).and_return(@expected_user)
 120     user = Twitter::User.find(@id, @twitter)
 121     user.should eql(@expected_user)
 122
 123     # case where id => @screen_name, which is also valid
 124     @twitter.should_receive(:user).with(@screen_name).and_return(@expected_user)
 125     user = Twitter::User.find(@screen_name, @twitter)
 126     user.should eql(@expected_user)
 127   end
 128
 129   after(:each) do
 130     nilize(@twitter, @id, @screen_name, @expected_user)
 131   end
 132 end
 133
 134 describe Twitter::Status, ".find" do
 135   before(:each) do
 136     @twitter = Twitter::Client.from_config 'config/twitter.yml'
 137     @id = 9439843
 138     @text = 'My crummy status message'
 139     @user = Twitter::User.new(:id => @id, :screen_name => @screen_name)
 140     @expected_status = Twitter::Status.new(:id => @id, :text => @text, :user => @user)
 141   end
 142
 143   it "should invoke given Twitter::Client's #status method with expected arguments" do
 144     @twitter.should_receive(:status).with(:get, @id).and_return(@expected_status)
 145     status = Twitter::Status.find(@id, @twitter)
 146     status.should eql(@expected_status)
 147   end
 148
 149   after(:each) do
 150     nilize(@twitter, @id, @text, @user, @expected_status)
 151   end
 152 end
 153
 154 describe Test::Model, "#bless" do
 155   before(:each) do
 156     @twitter = Twitter::Client.from_config('config/twitter.yml')
 157     @model = Test::Model.new
 158   end
 159
 160   it "should delegate to #basic_bless" do
 161     @model.should_receive(:basic_bless).and_return(@twitter)
 162     @model.bless(@twitter)
 163   end
 164
 165   it "should set client attribute of self" do
 166     @model.should_receive(:client=).once
 167     @model.bless(@twitter)
 168   end
 169
 170   after(:each) do
 171     nilize(@model, @twitter)
 172   end
 173 end
 174
 175 describe Twitter::User, "#is_me?" do
 176   before(:each) do
 177     @twitter = Twitter::Client.from_config('config/twitter.yml')
 178     @user_not_me = Twitter::User.new(:screen_name => 'notmylogin')
 179     @user_me = Twitter::User.new(:screen_name => @twitter.instance_eval("@login"))
 180     @user_not_me.bless(@twitter)
 181     @user_me.bless(@twitter)
 182   end
 183
 184   it "should return true when Twitter::User object represents authenticated user of client context" do
 185     @user_me.is_me?.should be_true
 186   end
 187
 188   it "should return false when Twitter::User object does not represent authenticated user of client context" do
 189     @user_not_me.is_me?.should be_false
 190   end
 191
 192   after(:each) do
 193     nilize(@twitter, @user_not_me, @user_me)
 194   end
 195 end
 196
 197 describe Twitter::User, "#bless(client)" do
 198   before(:each) do
 199     @twitter = Twitter::Client.from_config('config/twitter.yml')
 200     @user_not_me = Twitter::User.new(:screen_name => 'notmylogin')
 201     @user_me = Twitter::User.new(:screen_name => @twitter.instance_eval("@login"))
 202   end
 203
 204   it "should add a followers method" do
 205     @user_me.should_not respond_to?(:followers)
 206     @user_me.bless(@twitter)
 207     @user_me.should respond_to?(:followers)
 208   end
 209
 210   it "should not add a followers method" do
 211     @user_not_me.should_not respond_to?(:followers)
 212     @user_not_me.bless(@twitter)
 213     @user_not_me.should_not respond_to?(:followers)
 214   end
 215
 216   after(:each) do
 217     nilize(@twitter, @user_not_me, @user_me)
 218   end
 219 end
 220
 221 describe Twitter::User, "#friends" do
 222   before(:each) do
 223     @twitter = Twitter::Client.from_config('config/twitter.yml')
 224     @id = 5701682
 225     @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
 226     @user.bless(@twitter)
 227   end
 228
 229   it "should delegate to @client.user(@id, :friends)" do
 230     @twitter.should_receive(:user).with(@id, :friends)
 231     @user.friends
 232   end
 233
 234   after(:each) do
 235     nilize(@twitter, @id, @user)
 236   end
 237 end
 238
 239 describe Twitter::User, "#followers" do
 240   before(:each) do
 241     @twitter = Twitter::Client.from_config('config/twitter.yml')
 242     @id = 5701682
 243     @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
 244     @user.bless(@twitter)
 245   end
 246
 247   it "should delegate to @client.user(@id, :followers)" do
 248     @twitter.should_receive(:user).with(@id, :followers)
 249     @user.followers
 250   end
 251
 252   after(:each) do
 253     nilize(@twitter, @id, @user)
 254   end
 255 end
 256
 257 describe Test::Model, "#to_i" do
 258   before(:each) do
 259         @id = 234324285
 260         class Test::Model
 261                 attr_accessor :id
 262         end
 263     @model = Test::Model.new(:id => @id)
 264   end
 265
 266   it "should return @id attribute" do
 267     @model.to_i.should eql(@id)
 268   end
 269
 270   after(:each) do
 271     nilize(@model, @id)
 272   end
 273 end
 274
 275 describe Test::Model, "#to_s" do
 276   before(:each) do
 277         class Test::Model
 278                 attr_accessor :text
 279         end
 280         @text = 'Some text for the message body here'
 281     @model = Test::Model.new(:text => @text)
 282   end
 283
 284   it "should return expected text when a @text attribute exists for the model" do
 285     @model.to_s.should eql(@text)
 286   end
 287
 288   after(:each) do
 289     nilize(@model)
 290   end
 291 end
 292
 293 describe Twitter::Message, ".find" do
 294   it "should raise NotImplementedError due to Twitter (as opposed to Twitter4R) API limitation" do
 295     lambda {
 296         Twitter::Message.find(123, nil)
 297     }.should raise_error(NotImplementedError)
 298   end
 299 end
 300
 301 describe Twitter::Status, ".create" do
 302   before(:each) do
 303     @twitter = client_context
 304     @text = 'My status update'
 305     @status = Twitter::Status.new(:text => @text, :client => @twitter)
 306   end
 307
 308   it "should invoke #status(:post, text) on client context given" do
 309     @twitter.should_receive(:status).with(:post, @text).and_return(@status)
 310     Twitter::Status.create(:text => @text, :client => @twitter)
 311   end
 312
 313   it "should raise an ArgumentError when no client is given in params" do
 314     lambda {
 315         Twitter::Status.create(:text => @text)
 316     }.should raise_error(ArgumentError)
 317   end
 318
 319   it "should raise an ArgumentError when no text is given in params" do
 320         @twitter.should_receive(:is_a?).with(Twitter::Client)
 321     lambda {
 322         Twitter::Status.create(:client => @twitter)
 323     }.should raise_error(ArgumentError)
 324   end
 325
 326   it "should raise an ArgumentError when text given in params is not a String" do
 327     lambda {
 328         Twitter::Status.create(:client => @twitter, :text => 234493)
 329     }.should raise_error(ArgumentError)
 330   end
 331
 332   it "should raise an ArgumentError when client context given in params is not a Twitter::Client object" do
 333     lambda {
 334         Twitter::Status.create(:client => 'a string instead of a Twitter::Client', :text => @text)
 335     }.should raise_error(ArgumentError)
 336   end
 337
 338   after(:each) do
 339     nilize(@twitter, @text, @status)
 340   end
 341 end
 342
 343 describe Twitter::Message, ".create" do
 344   before(:each) do
 345     @twitter = client_context
 346     @text = 'Just between you and I, Lantana and Gosford Park are two of my favorite movies'
 347     @recipient = Twitter::User.new(:id => 234958)
 348     @message = Twitter::Message.new(:text => @text, :recipient => @recipient)
 349   end
 350
 351   it "should invoke #message(:post, text, recipient) on client context given" do
 352     @twitter.should_receive(:message).with(:post, @text, @recipient).and_return(@message)
 353     Twitter::Message.create(:client => @twitter, :text => @text, :recipient => @recipient)
 354   end
 355
 356   it "should raise an ArgumentError if no client context is given in params" do
 357     lambda {
 358         Twitter::Message.create(:text => @text, :recipient => @recipient)
 359     }.should raise_error(ArgumentError)
 360   end
 361
 362   it "should raise an ArgumentError if client conext given in params is not a Twitter::Client object" do
 363     lambda {
 364         Twitter::Message.create(
 365                 :client => 3.14159,
 366                 :text => @text,
 367                 :recipient => @recipient)
 368     }.should raise_error(ArgumentError)
 369   end
 370
 371   it "should raise an ArgumentError if no text is given in params" do
 372         @twitter.should_receive(:is_a?).with(Twitter::Client)
 373     lambda {
 374         Twitter::Message.create(
 375                 :client => @twitter,
 376                 :recipient => @recipient)
 377     }.should raise_error(ArgumentError)
 378   end
 379
 380   it "should raise an ArgumentError if text given in params is not a String" do
 381     @twitter.should_receive(:is_a?).with(Twitter::Client)
 382     lambda {
 383         Twitter::Message.create(
 384                 :client => @twitter,
 385                 :text => Object.new,
 386                 :recipient => @recipient)
 387     }.should raise_error(ArgumentError)
 388   end
 389
 390   it "should raise an ArgumentError if no recipient is given in params" do
 391     @text.should_receive(:is_a?).with(String)
 392     lambda {
 393         Twitter::Message.create(
 394                 :client => @twitter,
 395                 :text => @text)
 396     }.should raise_error(ArgumentError)
 397   end
 398
 399   it "should raise an ArgumentError if recipient given in params is not a Twitter::User, Integer or String object" do
 400     @text.should_receive(:is_a?).with(String)
 401     lambda {
 402         Twitter::Message.create(
 403                 :client => @twitter,
 404                 :text => @text,
 405                 :recipient => 3.14159)
 406     }.should raise_error(ArgumentError)
 407   end
 408
 409   after(:each) do
 410     nilize(@twitter, @text, @recipient, @message)
 411   end
 412 end
 413
 414 describe Twitter::User, "#befriend" do
 415   before(:each) do
 416     @twitter = client_context
 417     @user = Twitter::User.new(
 418         :id => 1234,
 419         :screen_name => 'mylogin',
 420         :client => @twitter)
 421     @friend = Twitter::User.new(
 422         :id => 5678,
 423         :screen_name => 'friend',
 424         :client => @twitter)
 425   end
 426
 427   it "should invoke #friend(:add, user) on client context" do
 428     @twitter.should_receive(:friend).with(:add, @friend).and_return(@friend)
 429     @user.befriend(@friend)
 430   end
 431
 432   after(:each) do
 433     nilize(@twitter, @user, @friend)
 434   end
 435 end
 436
 437 describe Twitter::User, "#defriend" do
 438   before(:each) do
 439     @twitter = client_context
 440     @user = Twitter::User.new(
 441         :id => 1234,
 442         :screen_name => 'mylogin',
 443         :client => @twitter)
 444     @friend = Twitter::User.new(
 445         :id => 5678,
 446         :screen_name => 'friend',
 447         :client => @twitter)
 448   end
 449
 450   it "should invoke #friend(:remove, user) on client context" do
 451     @twitter.should_receive(:friend).with(:remove, @friend).and_return(@friend)
 452     @user.defriend(@friend)
 453   end
 454
 455   after(:each) do
 456     nilize(@twitter, @user, @friend)
 457   end
 458 end