flickrmocks 0.8.5

data/spec/models/photo_size_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe APP::PhotoSize do
+  let(:klass){APP::PhotoSize}
+  let(:fixtures){ APP::Fixtures.new}
+  let(:size_fixture){fixtures.photo_size}
+
+  subject {klass.new size_fixture}
+
+  context "#initialize" do
+    context "size fixture" do
+      it "returns object of proper class" do
+        subject.should be_a(APP::PhotoSize)
+      end
+    end
+    context "FlickRaw::ResponseList object" do
+      it "raises error" do
+        expect {
+          klass.new(fixtures.photos)
+        }.to raise_error(ArgumentError)
+      end
+    end
+    context "unexpected object" do
+      it "raises error when array object provided" do
+        expect{
+          klass.new([])
+        }.to raise_error(ArgumentError)
+      end
+      it "raises error when Hash object provided" do
+        expect{
+          klass.new({})
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "instance methods" do
+    specify {subject.should respond_to(:size)}
+    describe "#size" do
+      it "should return proper size" do
+        subject.size.should == size_fixture.label.downcase.sub('_',' ').to_s
+      end
+    end
+
+    specify {subject.should respond_to(:id)}
+    describe "#id" do
+      it "should return proper :id" do
+        subject.id.should == size_fixture.source.split('/')[-1].split('_')[0]
+      end
+    end
+
+    specify {subject.should respond_to(:secret)}
+    describe "#secret" do
+      it "should return :secret" do
+        subject.secret.should == size_fixture.source.split('/')[-1].split('_')[1]
+      end
+    end
+
+
+    specify{subject.should respond_to(:==)}
+    context "#==" do
+      it "returns true when object is compared to clone of itself" do
+        subject.should == subject.clone
+      end
+      it "returns true when object is compared to an array" do
+        subject.should_not == [1,2,3,4]
+      end
+      it "returns false when compared to object that is different in one attribute" do
+        subject.delegated_instance_methods do |method|
+          value = case subject.send(method)
+          when String then Faker::Lorem.sentence(3)
+          when FixNum then Random.rand
+          else Random.rand
+          end
+          other = subject.clone
+          other.stub(method).returns(value)
+          subject.should_not == other
+        end
+      end
+    end
+  end
+
+  context "metaprogramming methods" do
+
+    context "#delegated_instance_methods" do
+      it "should delegate to FlickRaw::Response" do  
+        subject.delegated_instance_methods.sort.should == fixtures.expected_methods.photo_size.sort
+      end
+    end
+
+    context "#respond_to?" do
+      it "returns true when given on of delegated_instance methods" do
+        subject.delegated_instance_methods.each do |method|
+          subject.should respond_to(method)
+        end
+      end
+      it "returns true when given expected methods" do
+        subject.methods do |method|
+          subject.should respond_to(method)
+        end
+      end
+    end
+
+    context "#methods" do
+      it "returns list that includes the methods that are delegated" do
+        expected_methods = subject.old_methods + fixtures.expected_methods.photo_size
+        (subject.methods - expected_methods).should be_empty
+        subject.methods.length.should == expected_methods.length
+      end
+
+    end
+  end
+  
+  context "custom cloning methods" do
+    context "#initialize_copy" do
+      it "returns photo object that have distinct __id__ as compared with original" do
+        other = subject.clone
+        subject.instance_eval('@delegated_to_object.__id__').should_not == other.instance_eval('@delegated_to_object.__id__')
+      end
+    end
+  end
+end

data/spec/models/photo_sizes_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe APP::PhotoSizes do
+  let(:klass){APP::PhotoSizes}
+  let(:fixtures){APP::Fixtures.new}
+
+  subject {APP::PhotoSizes.new fixtures.photo_sizes}
+
+  context "initialize" do
+    context "with FlickRaw::ResponseList" do
+      it "returns object of proper class" do
+        klass.new(fixtures.photo_sizes).should be_a(APP::PhotoSizes)
+      end
+    end
+    context "with FlickRaw::Response" do
+      it "raises an error" do
+        expect {
+          klass.new(fixtures.photo)
+        }.to raise_error(ArgumentError)
+
+      end
+    end
+    context "with an Array object" do
+      it "raises an error" do
+        expect {
+          klass.new([])
+        }.to raise_error(ArgumentError)
+      end
+    end
+    context "with a nil object" do
+      it "raises an error" do
+        expect {
+          klass.new(nil)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  context "instance methods" do
+    specify {subject.should respond_to(:id)}
+    context "#id" do
+      it "returns id for expected photo" do
+        subject.id.should == fixtures.photo_size.source.split('/')[-1].split('_')[0]
+      end
+    end
+
+    specify {subject.should respond_to(:secret)}
+    context "#secret" do
+      it "returns secret for correct photo" do
+        subject.secret.should == fixtures.photo_size.source.split('/')[-1].split('_')[1]
+      end
+    end
+
+    specify {subject.should respond_to(:sizes)}
+    context "#sizes" do
+      it "returns array of PhotoSize objects" do
+        subject.sizes.should == subject.map do |size| size end
+      end
+    end
+
+    specify {subject.should respond_to(:available_sizes)}
+    context "#available_sizes" do
+      it "returns array of sizes availalbe" do
+        subject.available_sizes.should == subject.sizes.map do |size|
+          size.size.to_sym
+        end
+      end
+    end
+
+    specify {subject.should respond_to(:possible_sizes)}
+      context "possible_sizes" do
+        it "returns list of sizes that are possible for an image" do
+          subject.possible_sizes == FlickrMocks::Models::Helpers.possible_sizes
+        end
+    end
+    specify {subject.should respond_to(:to_s)}
+    context "#to_s" do
+      it "should return expected string" do
+        expected = subject.map do |size| "#{size.label.downcase.sub(' ','_')}:#{size.width}x#{size.height}" end.join(',')
+        subject.to_s.should == expected
+      end
+    end
+
+    specify {subject.should respond_to(:==)}
+    describe "#==" do
+      it "returns true when object is compared to itself" do
+        subject.should == subject
+      end
+      it "returns true when object is compared to clone of itself" do
+        subject.should == subject.clone
+      end
+      it "returns false when object is compared to Fixnum" do
+        subject.should_not == 2
+      end
+      it "returns false when object is compared to Array" do
+        subject.should_not == []
+      end
+      it "returns false when object compared to object with only a single difference" do
+        other = subject.clone
+        other[0].instance_eval('@delegated_to_object').instance_eval('@h["label"] = "random size"')
+        subject.should_not == other
+      end
+    end
+
+    context "#collection" do
+
+      specify { subject.should respond_to(:collection)}
+      context "#collection" do
+        let(:reference){
+          OpenStruct.new :current_page => 1,
+          :per_page => subject.available_sizes.length,
+          :total_entries => subject.available_sizes.length,
+          :collection => subject.sizes
+        }
+        it_behaves_like "object that responds to collection"
+      end
+    end
+  end
+
+  context "metaprogramming methods" do
+
+    specify{subject.should respond_to(:delegated_instance_methods)}
+    context "#delegated_instance_methods" do
+      it "returns array accessor methods + size methods" do
+        subject.delegated_instance_methods.sort.should == (subject.possible_sizes +
+                                                                           APP::Models::Helpers.array_accessor_methods).sort
+      end
+    end
+
+    specify{subject.should respond_to(:methods)}
+    context "#methods" do
+      it "returns all methods including those that are delegated" do
+        subject.methods.sort.should == ( subject.delegated_instance_methods +
+            subject.old_methods).sort
+      end
+    end
+
+    specify{ subject.should respond_to(:respond_to?)}
+    context "#respond_to?" do
+      it "recognizes all methods returned by #methods" do
+        subject.methods.each do |method|
+          subject.should respond_to(method)
+        end
+      end
+    end
+
+    context "iteratable methods" do
+      let(:reference) {subject.sizes}
+      it_behaves_like "object with delegated Array accessor helpers"
+    end
+
+  end
+
+  context "custom cloning methods" do
+    context "initialize_copy" do
+      it "returns clone with distinct id from original object" do
+        other = subject.clone
+        subject.each_index do |index|
+          subject[index].__id__.should_not == other[index].__id__
+        end
+      end
+    end
+  end
+  
+end
+
+
+

data/spec/models/photo_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe APP::Photo do
+  let(:klass){APP::Photo}
+  let(:fixtures){APP::Fixtures.new}
+  let(:basic_photo){klass.new fixtures.photo}
+  let(:extended_photo){klass.new fixtures.photo_details}
+
+  subject {basic_photo}
+
+  context "initialize" do
+    context "with extended photo" do
+      it "returns object of proper class" do
+        klass.new(fixtures.photo_details).should be_a(APP::Photo)
+      end
+    end
+
+    context "with basic photo" do
+      subject {klass.new fixtures.photo}
+      it "returns object of proper class" do
+        klass.new(fixtures.photo).should be_a(APP::Photo)
+      end
+    end
+    context "with nil" do
+      it "raises error" do
+        expect { klass.new nil}.to raise_error(ArgumentError)
+      end
+    end
+    context "with FlickRaw::ResponseList class" do
+      it "raises error" do
+        expect { klass.new fixtures.photos}.to raise_error(ArgumentError)
+      end
+    end
+    context "with an Array class" do
+      it "raises error" do
+        expect { klass.new []}.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "instance methods" do
+    specify {subject.should respond_to(:photo_id)}
+    context "#photo_id" do
+      it "returns correct photo_id" do
+        subject.photo_id.should == subject.id
+      end
+    end
+
+    specify {subject.should respond_to(:usable?)}
+    context "#usable?" do
+      context "licenses that DO NOT reserve ALL copyright" do
+        it "returns false when license is '0'" do
+          subject.stub(:license).and_return("0")
+          subject.should_not be_usable
+        end
+      end
+      context "licenses that DO NOT allow for commercial usage" do
+        it "returns false when license is '1'" do
+          subject.stub(:license).and_return("1")
+          subject.should_not be_usable
+        end
+        it "returns false when license is '2'" do
+          subject.stub(:license).and_return("2")
+          subject.should_not be_usable
+        end
+        it "returns false when license is '3'" do
+          subject.stub(:license).and_return("3")
+          subject.should_not be_usable
+        end
+      end
+      context "licenses that allow for commercial usage" do
+        it "returns false when license is '4'" do
+          subject.stub(:license).and_return('4')
+          subject.should be_usable
+        end
+        it "returns false when license is '5'" do
+          subject.stub(:license).and_return('5')
+          subject.should be_usable
+        end
+        it "returns false when license is '6'" do
+          subject.stub(:license).and_return('6')
+          subject.should be_usable
+        end
+      end
+    end
+
+    context "url image helpers" do
+      context "basic photo" do
+        subject {basic_photo}
+        it_behaves_like "object with flickr image url helpers"
+      end
+
+      context "extended photo" do
+        subject {extended_photo}
+        it_behaves_like "object with flickr image url helpers"
+      end
+      
+      context "#original" do
+        context "basic photo" do
+          subject  {basic_photo}
+          specify {subject.should respond_to(:original)}
+          it "returns nil for basic photo" do
+            subject.original.should be_nil
+          end
+        end        
+        context "extended photo" do
+          subject  {extended_photo}
+          specify {subject.should respond_to(:original)}
+          it "returns expected url for detail photo" do
+            subject.original.should == subject.square.sub('_%s_s.' % subject.secret, '_%s_o.' % subject.originalsecret)
+          end
+        end
+      end
+    end
+    
+    specify {subject.should respond_to(:owner_url)}
+    context "#owner_url" do
+      it "returns expected url link for owner of image" do
+        subject.owner_url.should == "http://www.flickr.com/photos/#{fixtures.photo['owner']}/#{fixtures.photo['id']}"
+      end
+    end
+
+    specify {subject.should respond_to(:owner_id)}
+    context "#owner_id" do
+      it "returns expected value id for owner of image" do
+        subject.owner_id.should == fixtures.photo['owner']
+      end
+
+    end
+
+    specify {subject.should respond_to(:owner)}
+    context "#owner" do
+      it "returns expected name for owner of image" do
+        subject.owner.should == fixtures.photo['owner']
+      end
+    end
+
+    specify{subject.should respond_to(:==)}
+    context "#==" do
+      subject {basic_photo}
+      context "basic photo" do
+        it "returns true when object is compared to itself" do
+          subject.should == subject
+        end
+        it "returns true when object is compared to clone of itself" do
+          subject.should == subject.clone
+        end
+
+        it "returns true when object is compared to an object of another class" do
+          subject.should_not == [1,2,3,4]
+        end
+        it "returns true when object is compared to another object with slight difference" do
+          subject.delegated_instance_methods.find_all do |value| value != :flickr_type end.each do |method|
+            other = subject.clone
+            value = case subject.send(method)
+            when String then Faker::Lorem.sentence(3)
+            when Fixnum then next
+            else Random.rand
+            end
+            other.instance_eval('@delegated_to_object').instance_eval('@h[method.to_s]=value')
+            subject.should_not == other
+          end
+        end
+      end
+
+      context "detailed photo" do
+        subject {extended_photo}
+
+        it "returns true when object is compared to itself" do
+          subject.should == subject
+        end
+        it "returns true when object is compared to clone of itself" do
+          subject.should == subject.clone
+        end
+        it "returns true when object is compared to an object of another class" do
+          other = subject.clone
+          other.instance_eval('@delegated_to_object').instance_eval('@h["dates"]').instance_eval('@h["taken"]="boobooje"')
+          subject.should_not == other
+        end
+
+        it "returns true when object is compared to another object with slight difference" do
+          subject.delegated_instance_methods.find_all do |value| value != :flickr_type end.each do |method|
+            other = subject.clone
+            value = case subject.send(method)
+            when String then Faker::Lorem.sentence(3)
+            when Fixnum then next
+            else Random.rand
+            end
+            other.instance_eval('@delegated_to_object').instance_eval('@h[method.to_s]=value')
+            subject.should_not == other
+          end
+        end
+      end
+    end
+
+  end
+
+
+  context "metaprogramming methods" do
+    context "#delegated_instance_methods" do
+      context "basic photo" do
+        subject {basic_photo}
+        it "returns methods for basic photos" do
+          subject.delegated_instance_methods.sort.should == fixtures.expected_methods.photo.sort
+        end
+      end
+      context "detailed photo" do
+        subject {extended_photo}
+        it "returns methods for extended photos" do
+          subject.delegated_instance_methods.sort.should == fixtures.expected_methods.photo_details.sort
+        end
+      end
+
+    end
+
+    context "#respond_to?" do
+      context "basic photo" do
+        subject {basic_photo}
+        it "responds to methods that are delegated to basic photo object" do
+          fixtures.expected_methods.photo.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+        it "responds to all methods returned by #methods" do
+          subject.methods.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+      end
+
+      context "detailed photo" do
+        subject {extended_photo}
+        it "responds to methods that are delegated to detailed photo object" do
+          fixtures.photo_details.methods(false).push(:flickr_type).each do |method|
+            subject.should respond_to(method)
+          end
+        end
+        it "responds to all methods returned by #methods" do
+          subject.methods.each do |method|
+            subject.should respond_to(method)
+          end
+        end
+      end
+    end
+
+    context "#methods" do
+      context "basic photo" do
+        subject {basic_photo}
+
+        specify {subject.should respond_to(:methods)}
+        it "returns expected methods including delegated methods for basic photo fixture" do
+          expected_methods = fixtures.expected_methods.photo + subject.old_methods
+          (subject.methods - expected_methods).should be_empty
+          subject.methods.length.should == expected_methods.length
+        end
+      end
+      context "detailed photo" do
+        subject {extended_photo}
+        specify {subject.should respond_to(:methods)}
+        it "returns expected methods including delegated methods to photo details fixture" do
+          expected_methods = fixtures.expected_methods.photo_details + subject.old_methods
+          (subject.methods - expected_methods).should be_empty
+          subject.methods.length.should == expected_methods.length
+        end
+      end
+    end
+
+  end
+
+  context "custom cloning methods" do
+    context "#initialize_copy" do
+      it "returns photo objects that have distinct @delegated_to_object ids from cloned object" do
+        other = subject.clone
+        subject.instance_eval("@delegated_to_object.__id__").should_not == other.instance_eval("@delegated_to_object.__id__")
+      end
+    end
+  end
+end