spec/twitter/model_spec.rb

   1 require File.expand_path(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, "#friends" do
 198   before(:each) do
 199     @twitter = Twitter::Client.from_config('config/twitter.yml')
 200     @id = 5701682
 201     @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
 202     @user.bless(@twitter)
 203   end
 204
 205   it "should delegate to @client.user(@id, :friends)" do
 206     @twitter.should_receive(:user).with(@id, :friends)
 207     @user.friends
 208   end
 209
 210   after(:each) do
 211     nilize(@twitter, @id, @user)
 212   end
 213 end
 214
 215 describe Twitter::User, "#followers" do
 216   before(:each) do
 217     @twitter = Twitter::Client.from_config('config/twitter.yml')
 218     @id = 5701682
 219     @user = Twitter::User.new(:id => @id, :screen_name => 'twitter4r')
 220     @user.bless(@twitter)
 221   end
 222
 223   it "should delegate to @client.my(:followers)" do
 224     @twitter.should_receive(:my).with(:followers, {})
 225     @user.followers
 226   end
 227
 228   after(:each) do
 229     nilize(@twitter, @id, @user)
 230   end
 231 end
 232
 233 describe Test::Model, "#to_i" do
 234   before(:each) do
 235     @id = 234324285
 236     class Test::Model
 237       attr_accessor :id
 238     end
 239     @model = Test::Model.new(:id => @id)
 240   end
 241
 242   it "should return @id attribute" do
 243     @model.to_i.should eql(@id)
 244   end
 245
 246   after(:each) do
 247     nilize(@model, @id)
 248   end
 249 end
 250
 251 describe Test::Model, "#to_s" do
 252   before(:each) do
 253     class Test::Model
 254       attr_accessor :text
 255     end
 256     @text = 'Some text for the message body here'
 257     @model = Test::Model.new(:text => @text)
 258   end
 259
 260   it "should return expected text when a @text attribute exists for the model" do
 261     @model.to_s.should eql(@text)
 262   end
 263
 264   after(:each) do
 265     nilize(@model)
 266   end
 267 end
 268
 269 describe Twitter::Message, ".find" do
 270   it "should raise NotImplementedError due to Twitter (as opposed to Twitter4R) API limitation" do
 271     lambda {
 272       Twitter::Message.find(123, nil)
 273     }.should raise_error(NotImplementedError)
 274   end
 275 end
 276
 277 describe Twitter::Status, ".create" do
 278   before(:each) do
 279     @twitter = client_context
 280     @text = 'My status update'
 281     @status = Twitter::Status.new(:text => @text, :client => @twitter)
 282   end
 283
 284   it "should invoke #status(:post, text) on client context given" do
 285     @twitter.should_receive(:status).with(:post, @text).and_return(@status)
 286     Twitter::Status.create(:text => @text, :client => @twitter)
 287   end
 288
 289   it "should raise an ArgumentError when no client is given in params" do
 290     lambda {
 291       Twitter::Status.create(:text => @text)
 292     }.should raise_error(ArgumentError)
 293   end
 294
 295   it "should raise an ArgumentError when no text is given in params" do
 296     @twitter.should_receive(:is_a?).with(Twitter::Client)
 297     lambda {
 298       Twitter::Status.create(:client => @twitter)
 299     }.should raise_error(ArgumentError)
 300   end
 301
 302   it "should raise an ArgumentError when text given in params is not a String" do
 303     lambda {
 304       Twitter::Status.create(:client => @twitter, :text => 234493)
 305     }.should raise_error(ArgumentError)
 306   end
 307
 308   it "should raise an ArgumentError when client context given in params is not a Twitter::Client object" do
 309     lambda {
 310       Twitter::Status.create(:client => 'a string instead of a Twitter::Client', :text => @text)
 311     }.should raise_error(ArgumentError)
 312   end
 313
 314   after(:each) do
 315     nilize(@twitter, @text, @status)
 316   end
 317 end
 318
 319 describe Twitter::Message, ".create" do
 320   before(:each) do
 321     @twitter = client_context
 322     @text = 'Just between you and I, Lantana and Gosford Park are two of my favorite movies'
 323     @recipient = Twitter::User.new(:id => 234958)
 324     @message = Twitter::Message.new(:text => @text, :recipient => @recipient)
 325   end
 326
 327   it "should invoke #message(:post, text, recipient) on client context given" do
 328     @twitter.should_receive(:message).with(:post, @text, @recipient).and_return(@message)
 329     Twitter::Message.create(:client => @twitter, :text => @text, :recipient => @recipient)
 330   end
 331
 332   it "should raise an ArgumentError if no client context is given in params" do
 333     lambda {
 334       Twitter::Message.create(:text => @text, :recipient => @recipient)
 335     }.should raise_error(ArgumentError)
 336   end
 337
 338   it "should raise an ArgumentError if client conext given in params is not a Twitter::Client object" do
 339     lambda {
 340       Twitter::Message.create(
 341         :client => 3.14159,
 342         :text => @text,
 343         :recipient => @recipient)
 344     }.should raise_error(ArgumentError)
 345   end
 346
 347   it "should raise an ArgumentError if no text is given in params" do
 348     @twitter.should_receive(:is_a?).with(Twitter::Client)
 349     lambda {
 350       Twitter::Message.create(
 351         :client => @twitter,
 352         :recipient => @recipient)
 353     }.should raise_error(ArgumentError)
 354   end
 355
 356   it "should raise an ArgumentError if text given in params is not a String" do
 357     @twitter.should_receive(:is_a?).with(Twitter::Client)
 358     lambda {
 359       Twitter::Message.create(
 360         :client => @twitter,
 361         :text => Object.new,
 362         :recipient => @recipient)
 363     }.should raise_error(ArgumentError)
 364   end
 365
 366   it "should raise an ArgumentError if no recipient is given in params" do
 367     @text.should_receive(:is_a?).with(String)
 368     lambda {
 369       Twitter::Message.create(
 370         :client => @twitter,
 371         :text => @text)
 372     }.should raise_error(ArgumentError)
 373   end
 374
 375   it "should raise an ArgumentError if recipient given in params is not a Twitter::User, Integer or String object" do
 376     @text.should_receive(:is_a?).with(String)
 377     lambda {
 378       Twitter::Message.create(
 379         :client => @twitter,
 380         :text => @text,
 381         :recipient => 3.14159)
 382     }.should raise_error(ArgumentError)
 383   end
 384
 385   after(:each) do
 386     nilize(@twitter, @text, @recipient, @message)
 387   end
 388 end
 389
 390 describe Twitter::User, "#befriend" do
 391   before(:each) do
 392     @twitter = client_context
 393     @user = Twitter::User.new(
 394       :id => 1234,
 395       :screen_name => 'mylogin',
 396       :client => @twitter)
 397     @friend = Twitter::User.new(
 398       :id => 5678,
 399       :screen_name => 'friend',
 400       :client => @twitter)
 401   end
 402
 403   it "should invoke #friend(:add, user) on client context" do
 404     @twitter.should_receive(:friend).with(:add, @friend).and_return(@friend)
 405     @user.befriend(@friend)
 406   end
 407
 408   after(:each) do
 409     nilize(@twitter, @user, @friend)
 410   end
 411 end
 412
 413 describe Twitter::User, "#defriend" do
 414   before(:each) do
 415     @twitter = client_context
 416     @user = Twitter::User.new(
 417       :id => 1234,
 418       :screen_name => 'mylogin',
 419       :client => @twitter)
 420     @friend = Twitter::User.new(
 421       :id => 5678,
 422       :screen_name => 'friend',
 423       :client => @twitter)
 424   end
 425
 426   it "should invoke #friend(:remove, user) on client context" do
 427     @twitter.should_receive(:friend).with(:remove, @friend).and_return(@friend)
 428     @user.defriend(@friend)
 429   end
 430
 431   after(:each) do
 432     nilize(@twitter, @user, @friend)
 433   end
 434 end
 435
 436 describe Twitter::Status, "#reply?" do
 437   before(:each) do
 438     @status = Twitter::Status.new(
 439       :id => 123456789,
 440       :text => "Wazzup?",
 441       :user => mock(Twitter::User)
 442     )
 443     @reply = Twitter::Status.new(
 444       :text => "No much bro.  You?",
 445       :user => mock(Twitter::User),
 446       :in_reply_to_status_id => @status.id
 447     )
 448   end
 449
 450   it "should return false for the original status" do
 451     @status.reply?.should be(false)
 452   end
 453
 454   it "should return true for the reply to the original status" do
 455     @reply.reply?.should be(true)
 456   end
 457 end
 458
 459 describe Twitter::Status, "#reply(status_text)" do
 460   before(:each) do
 461     @twitter = client_context
 462     @status = Twitter::Status.new(
 463         :id => 1234,
 464         :text => "The status text",
 465         :client => @twitter)
 466     @reply_text = "Reply text goes here"
 467     @reply_status = Twitter::Status.new()
 468   end
 469
 470   it "should invoke #status(:reply, :status => ..., :in_reply_to_status_id => ...) on client context" do
 471     @twitter.should_receive(:status).with(:reply, :status => @reply_text, :in_reply_to_status_id => @status.id).and_return(@reply_status)
 472     @status.reply(@reply_text)
 473   end
 474
 475   after(:each) do
 476     nilize(@twitter, @status)
 477   end
 478 end
 479
 480 describe Twitter::Status, "#to_s" do
 481   before(:each) do
 482     @text = 'Aloha'
 483     @status = Twitter::Status.new(:text => @text)
 484   end
 485
 486   it "should render text attribute" do
 487     @status.to_s.should be(@text)
 488   end
 489
 490   after(:each) do
 491     nilize(@text, @status)
 492   end
 493 end
 494
 495 describe Twitter::Message, "#to_s" do
 496   before(:each) do
 497     @text = 'Aloha'
 498     @message = Twitter::Message.new(:text => @text)
 499   end
 500
 501   it "should render text attribute" do
 502     @message.to_s.should be(@text)
 503   end
 504
 505   after(:each) do
 506     nilize(@text, @message)
 507   end
 508 end