jubjub 0.0.7 → 0.0.8

data/spec/models/muc_affiliation_collection_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Jubjub::Muc::AffiliationCollection do
+
+  describe "that are proxied like" do
+
+    before do
+      @mock_connection = mock
+      @affiliations = [
+        muc_affiliation_factory( :affiliation => 'owner' ),
+        muc_affiliation_factory( :affiliation => 'admin' )
+      ]
+      # Hack to get around the fact that [] calls retrieve_affiliations several times with different affiliations
+      @mock_connection.stub_chain( :muc, :retrieve_affiliations ).with{|jid,affiliation| affiliation == "owner" }.and_return(@affiliations)
+      @mock_connection.stub_chain( :muc, :retrieve_affiliations ).with{|jid,affiliation| affiliation != "owner" }.and_return([])
+    end
+
+    describe "inspect" do
+
+      it "should show the list of affiliations, not Muc::AffiliationCollection" do
+        Jubjub::Muc::AffiliationCollection.new('conference.foo.com', @mock_connection).inspect.should eql(@affiliations.inspect)
+      end
+
+    end
+
+    describe "map" do
+
+      it "should pass the block to the rooms" do
+        c = Jubjub::Muc::AffiliationCollection.new('conference.foo.com', @mock_connection)
+        c.map{|r| r.affiliation.to_s }.should eql(['owner', 'admin'])
+      end
+
+    end
+
+  end
+
+  describe "instance method" do
+
+    describe "jid" do
+      it "should return the jid" do
+        Jubjub::Muc::AffiliationCollection.new("conference.foo.com", mock).jid.should == Jubjub::Jid.new("conference.foo.com")
+      end
+    end
+
+    describe "[]" do
+      before do
+        @mock_connection = mock
+        @affiliations = [
+          muc_affiliation_factory( :jid => 'theozaurus@foo.com',   :affiliation => 'owner' ),
+          muc_affiliation_factory( :jid => 'dragonzaurus@foo.com', :affiliation => 'member' )
+        ]
+        # Hack to get around the fact that [] calls retrieve_affiliations several times with different affiliations
+        @mock_connection.stub_chain( :muc, :retrieve_affiliations ).with{|jid,affiliation| affiliation == "owner" }.and_return(@affiliations)
+        @mock_connection.stub_chain( :muc, :retrieve_affiliations ).with{|jid,affiliation| affiliation != "owner" }.and_return([])
+      end
+
+      subject { Jubjub::Muc::AffiliationCollection.new "conference.foo.com", @mock_connection }
+
+      it "should call retrieve_affiliations with owner, outcast, member, admin" do
+        muc_mock = mock
+        @mock_connection.stub(:muc).and_return(muc_mock)
+        muc_mock.should_receive(:retrieve_affiliations).with(subject.jid, 'owner')
+        muc_mock.should_receive(:retrieve_affiliations).with(subject.jid, 'outcast')
+        muc_mock.should_receive(:retrieve_affiliations).with(subject.jid, 'member')
+        muc_mock.should_receive(:retrieve_affiliations).with(subject.jid, 'admin')
+
+        subject[0]
+      end
+
+      it "should work like a normal array when passed a Fixnum" do
+        subject[1].should == @affiliations[1]
+      end
+
+      describe "searching by jid if a String" do
+
+        it "should return cached result if it has already searched" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:retrieve_affiliations)
+          subject.first
+          subject["theozaurus@foo.com"].should == @affiliations[0]
+        end
+
+        it "should return default result if it has already searched and does not exist" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:retrieve_affiliations)
+          subject.first
+          subject['blogozaurus@foo.com'].should ==
+            muc_affiliation_factory( :muc_jid => 'conference.foo.com',
+                                     :jid => 'blogozaurus@foo.com',
+                                     :affiliation => 'none',
+                                     :role => nil,
+                                     :nick => nil )
+        end
+
+        it "should return default result if it has not already searched" do
+          @mock_connection.muc.should_not_receive(:retrieve_affiliations)
+          subject["theozaurus@foo.com"].should_not equal @affiliations[0]
+          subject["theozaurus@foo.com"].should ==
+            muc_affiliation_factory( :muc_jid => 'conference.foo.com',
+                                     :jid => 'theozaurus@foo.com',
+                                     :affiliation => 'none',
+                                     :role => nil,
+                                     :nick => nil )
+        end
+
+      end
+
+      describe "searching by Jid if a Jubjub::Jid" do
+
+        it "should return cached result if it has already searched" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:retrieve_affiliations)
+          subject.first
+          subject[Jubjub::Jid.new "theozaurus@foo.com"].should == @affiliations[0]
+        end
+
+        it "should return default result if it has already searched and does not exist" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:retrieve_affiliations)
+          subject.first
+          subject[Jubjub::Jid.new 'blogozaurus@foo.com'].should ==
+            muc_affiliation_factory( :muc_jid => 'conference.foo.com',
+                                     :jid => 'blogozaurus@foo.com',
+                                     :affiliation => 'none',
+                                     :role => nil,
+                                     :nick => nil )
+        end
+
+        it "should return default result if it has not already searched" do
+          @mock_connection.muc.should_not_receive(:retrieve_affiliations)
+          subject[Jubjub::Jid.new "theozaurus@foo.com"].should_not equal @affiliations[0]
+          subject[Jubjub::Jid.new "theozaurus@foo.com"].should ==
+            muc_affiliation_factory( :muc_jid => 'conference.foo.com',
+                                     :jid => 'theozaurus@foo.com',
+                                     :affiliation => 'none',
+                                     :role => nil,
+                                     :nick => nil )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/models/muc_affiliation_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Jubjub::Muc::Affiliation do
+
+  describe "instance method" do
+
+    describe "muc_jid" do
+      it "should return the muc_jid" do
+        p = muc_affiliation_factory :muc_jid => 'muc.foo.com'
+        p.muc_jid.should == Jubjub::Jid.new('muc.foo.com')
+      end
+    end
+
+    describe "jid" do
+      it "should return the jid" do
+        p = muc_affiliation_factory :jid => 'bob@foo.com'
+        p.jid.should == Jubjub::Jid.new('bob@foo.com')
+      end
+    end
+
+    describe "nick" do
+      it "should return the nick" do
+        p = muc_affiliation_factory :nick => 'bob'
+        p.nick.should == 'bob'
+      end
+    end
+
+    describe "role" do
+      it "should return the role" do
+        p = muc_affiliation_factory :role => 'moderator'
+        p.role.should == 'moderator'
+      end
+    end
+
+    describe "affiliation" do
+      it "should return the affiliation" do
+        p = muc_affiliation_factory :affiliation => 'admin'
+        p.affiliation.should == 'admin'
+      end
+    end
+
+    describe "owner?" do
+      it "should return true when affiliation is 'owner'" do
+        muc_affiliation_factory( :affiliation => 'owner' ).owner?.should equal(true)
+      end
+
+      it "should return false when affiliation is not 'owner'" do
+        muc_affiliation_factory( :affiliation => 'admin' ).owner?.should equal(false)
+      end
+    end
+
+    describe "admin?" do
+      it "should return true when affiliation is 'admin'" do
+        muc_affiliation_factory( :affiliation => 'admin' ).admin?.should equal(true)
+      end
+
+      it "should return false when affiliation is not 'admin'" do
+        muc_affiliation_factory( :affiliation => 'owner' ).admin?.should equal(false)
+      end
+    end
+
+    describe "member?" do
+      it "should return true when affiliation is 'member'" do
+        muc_affiliation_factory( :affiliation => 'member' ).member?.should equal(true)
+      end
+
+      it "should return false when affiliation is not 'member'" do
+        muc_affiliation_factory( :affiliation => 'publisher' ).member?.should equal(false)
+      end
+    end
+
+    describe "none?" do
+      it "should return true when affiliation is 'none'" do
+        muc_affiliation_factory( :affiliation => 'none' ).none?.should equal(true)
+      end
+
+      it "should return false when affiliation is not 'none'" do
+        muc_affiliation_factory( :affiliation => 'publisher' ).none?.should equal(false)
+      end
+    end
+
+    describe "outcast?" do
+      it "should return true when affiliation is 'outcast'" do
+        muc_affiliation_factory( :affiliation => 'outcast' ).outcast?.should equal(true)
+      end
+
+      it "should return false when affiliation is not 'outcast'" do
+        muc_affiliation_factory( :affiliation => 'publisher' ).outcast?.should equal(false)
+      end
+    end
+
+    describe "set" do
+      it "should redirect call to muc.modify_affiliations" do
+        @mock_connection = mock
+        @mock_connection.stub_chain :muc, :modify_affiliations
+
+        affiliation = muc_affiliation_factory :connection => @mock_connection
+
+        @mock_connection.muc.should_receive(:modify_affiliations).with( affiliation.muc_jid, affiliation )
+
+        affiliation.set 'admin'
+      end
+
+      describe "when succesful" do
+        before do
+          @mock_connection = mock
+          @mock_connection.stub_chain( :muc, :modify_affiliations ).and_return( true )
+        end
+
+        it "should return true" do
+          @affiliation = muc_affiliation_factory :connection => @mock_connection
+          @affiliation.set( 'admin' ).should equal( true )
+        end
+
+        it "should have affiliaton set to new value" do
+          @affiliation = muc_affiliation_factory :connection => @mock_connection, :affiliation => 'owner'
+          @affiliation.set 'admin'
+          @affiliation.affiliation.should == 'admin'
+        end
+      end
+
+      describe "when unsuccesful" do
+        before do
+          @mock_connection = mock
+          @mock_connection.stub_chain( :muc, :modify_affiliations ).and_return( false )
+        end
+
+        it "should return false" do
+          @affiliation = muc_affiliation_factory :connection => @mock_connection
+          @affiliation.set( 'admin' ).should equal( false )
+        end
+
+        it "should have affiliaton set to original value" do
+          @affiliation = muc_affiliation_factory :connection => @mock_connection, :affiliation => 'owner'
+          @affiliation.set 'admin'
+          @affiliation.affiliation.should == 'owner'
+        end
+      end
+    end
+
+    describe "set_owner" do
+      it "should redirect call to set" do
+        affiliation = muc_affiliation_factory
+        affiliation.should_receive(:set).with('owner').and_return( 'from-set' )
+
+        affiliation.set_owner.should == 'from-set'
+      end
+    end
+
+    describe "set_admin" do
+      it "should redirect call to set" do
+        affiliation = muc_affiliation_factory
+        affiliation.should_receive(:set).with('admin').and_return( 'from-set' )
+
+        affiliation.set_admin.should == 'from-set'
+      end
+    end
+
+    describe "set_member" do
+      it "should redirect call to set" do
+        affiliation = muc_affiliation_factory
+        affiliation.should_receive(:set).with('member').and_return( 'from-set' )
+
+        affiliation.set_member.should == 'from-set'
+      end
+    end
+
+    describe "set_none" do
+      it "should redirect call to set" do
+        affiliation = muc_affiliation_factory
+        affiliation.should_receive(:set).with('none').and_return( 'from-set' )
+
+        affiliation.set_none.should == 'from-set'
+      end
+    end
+
+    describe "set_outcast" do
+      it "should redirect call to set" do
+        affiliation = muc_affiliation_factory
+        affiliation.should_receive(:set).with('outcast').and_return( 'from-set' )
+
+        affiliation.set_outcast.should == 'from-set'
+      end
+    end
+
+    describe "==" do
+      it "should match equivalent objects" do
+        muc_affiliation_factory.should == muc_affiliation_factory
+      end
+
+      it "should not distinguish between connections" do
+        muc_affiliation_factory(:connection => 'wibble').should == muc_affiliation_factory(:connection => 'wobble')
+      end
+
+      it "should still match no matter how jid is initialized" do
+        muc_affiliation_factory(:jid => 'foo@bar.com').should == muc_affiliation_factory(:jid => Jubjub::Jid.new('foo@bar.com'))
+      end
+
+      it "should still match no matter how muc_jid is initialized" do
+        muc_affiliation_factory(:muc_jid => 'muc.bar.com').should ==
+        muc_affiliation_factory(:muc_jid => Jubjub::Jid.new('muc.bar.com'))
+      end
+
+      it "should not match objects with different attributes" do
+        muc_affiliation_factory(:muc_jid => 'a.b.com').should_not == muc_affiliation_factory
+        muc_affiliation_factory(:jid => 'a.b.com').should_not == muc_affiliation_factory
+        muc_affiliation_factory(:nick => 'snicker-snack').should_not == muc_affiliation_factory
+        muc_affiliation_factory(:role => 'owner').should_not == muc_affiliation_factory
+        muc_affiliation_factory(:affiliation => 'member').should_not == muc_affiliation_factory
+      end
+    end
+
+  end
+
+end

data/spec/models/muc_collection_spec.rb

@@ -1,42 +1,42 @@
 require 'spec_helper'
 
 describe Jubjub::Muc::Collection do
-  
+
   describe "instance methods" do
-    
+
     describe "create" do
-      
+
       before do
         @mock_connection = mock
         @mock_connection.stub(:jid).and_return( Jubjub::Jid.new 'admin@foo.com' )
         @mock_connection.stub_chain :muc, :create
       end
-      
+
       it "should call muc.create on connection" do
         @mock_connection.muc.should_receive(:create).with( Jubjub::Jid.new 'hello@conference.foo.com/admin' )
-        
+
         Jubjub::Muc::Collection.new("conference.foo.com", @mock_connection).create("hello")
       end
-      
+
       it "should yield a Muc::Configuration if a block is given" do
         @config = Jubjub::Muc::Configuration.new( "allow_query_users" => { :type => "boolean", :value => "1", :label => "Foo" } )
-        
+
         @mock_connection.muc.should_receive( :configuration ).with( Jubjub::Jid.new( 'hello@conference.foo.com/admin' )).and_return( @config )
         @mock_connection.muc.should_receive( :create        ).with( Jubjub::Jid.new( 'hello@conference.foo.com/admin' ), @config )
-        
+
         Jubjub::Muc::Collection.new("conference.foo.com", @mock_connection).create("hello"){|config|
           config.should == @config
         }
       end
-      
+
     end
-    
+
     describe "jid" do
       it "should return the jid" do
         Jubjub::Muc::Collection.new("conference.foo.com", mock).jid.should == Jubjub::Jid.new("conference.foo.com")
       end
     end
-    
+
     describe "[]" do
       before do
         @mock_connection = mock
@@ -46,33 +46,65 @@ describe Jubjub::Muc::Collection do
         ]
         @mock_connection.stub_chain( :muc, :list ).and_return(@rooms)
       end
-      
+
       subject { Jubjub::Muc::Collection.new('conference.foo.com', @mock_connection) }
-      
+
       it "should work like a normal array when passed a Fixnum" do
         subject[1].should == @rooms[1]
       end
-      
-      it "should search by node if a String" do
-        subject["room_1"].should == @rooms[0]
-      end
 
-      it "should return Jubjub::Muc if nothing found for a String as it may still exist" do
-        subject['made-up'].should == Jubjub::Muc.new('made-up@conference.foo.com', nil, @mock_connection)
-      end
-      
-      it "should search by jid if a Jubjub::Jid" do
-        subject[Jubjub::Jid.new("room_1@conference.foo.com")].should == @rooms[0]
+      describe "searching by node if a String" do
+
+        it "should return cached result if it has already searched" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:list)
+          subject.first
+          subject["room_1"].should == @rooms[0]
+        end
+
+        it "should return default result if it has already searched and does not exist" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:list)
+          subject.first
+          subject['made-up'].should == Jubjub::Muc.new('made-up@conference.foo.com', nil, @mock_connection)
+        end
+
+        it "should return default result if it has not already searched" do
+          @mock_connection.muc.should_not_receive(:list)
+          subject["room_1"].should_not equal @rooms[0]
+          subject["room_1"].should == Jubjub::Muc.new('room_1@conference.foo.com', nil, @mock_connection)
+        end
+
       end
-      
-      it "should return Jubjub::Muc if nothing found for a Jubjub::Jid as it may still exist" do
-        subject[Jubjub::Jid.new("made-up@conference.foo.com")].should == Jubjub::Muc.new('made-up@conference.foo.com', nil, @mock_connection)
+
+      describe "searching by jid if a Jubjub::Jid" do
+
+        it "should return cached result if it has already searched" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:list)
+          subject.first
+          subject[Jubjub::Jid.new("room_1@conference.foo.com")].should == @rooms[0]
+        end
+
+        it "should return default result if it has already searched and does not exist" do
+          # Trigger lookup
+          @mock_connection.muc.should_receive(:list)
+          subject.first
+          subject[Jubjub::Jid.new("made-up@conference.foo.com")].should == Jubjub::Muc.new('made-up@conference.foo.com', nil, @mock_connection)
+        end
+
+        it "should return default result if it has not already searched" do
+          @mock_connection.muc.should_not_receive(:list)
+          subject[Jubjub::Jid.new("room_1@conference.foo.com")].should_not equal @rooms[0]
+          subject[Jubjub::Jid.new("room_1@conference.foo.com")].should == Jubjub::Muc.new('room_1@conference.foo.com', nil, @mock_connection)
+        end
+
       end
 
     end
-    
+
     describe "that are proxied like" do
-      
+
       before do
         @mock_connection = mock
         @rooms = [
@@ -81,7 +113,7 @@ describe Jubjub::Muc::Collection do
         ]
         @mock_connection.stub_chain( :muc, :list ).and_return(@rooms)
       end
-      
+
       describe "inspect" do
 
         it "should show the list of rooms, not Muc::Collection" do
@@ -99,7 +131,7 @@ describe Jubjub::Muc::Collection do
 
       end
     end
-    
+
   end
-  
-end
+
+end