flickrmocks 0.8.5

data/spec/base/fixtures_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'ruby-debug'
+
+describe APP::Fixtures do
+
+  let(:klass) {APP::Fixtures}
+  let(:fixtures) {APP::Fixtures.new}
+  let(:subject) {fixtures}
+  
+  context "class methods" do
+    specify {klass.should respond_to(:repository)}
+    context "repository" do
+      it "returns expected directory for the repository" do
+        expected = File.expand_path(File.dirname(__FILE__) + '/../fixtures') + '/'
+        klass.repository.should == expected
+      end
+    end
+  end
+
+
+  context "instance_methods" do
+    shared_examples_for "a flickraw fixture" do
+      let (:subject) {fixtures.send(fixture)}
+      let(:expected_methods){fixtures.expected_methods.send(fixture)}
+      it "responds to expected methods" do
+        expected_methods.each do |method|
+          subject.should respond_to(method)
+        end
+      end
+    end
+
+
+
+    specify {subject.should respond_to(:photo)}
+    context "photo" do
+      let(:fixture) {:photo}
+      it_behaves_like "a flickraw fixture"
+    end
+    
+    specify {subject.should respond_to(:photos)}
+    context "photos" do
+      let(:fixture) {:photos}
+      it_behaves_like "a flickraw fixture"
+    end
+
+    specify {subject.should respond_to(:empty_photos)}
+    context "empty_photos" do
+      let(:fixture){:empty_photos}
+      it_behaves_like "a flickraw fixture"
+    end
+    
+    specify {subject.should respond_to(:photo_details)}
+    context "photo_details" do
+      let(:fixture) {:photo_details}
+      it_behaves_like "a flickraw fixture"
+    end
+
+    specify {subject.should respond_to(:interesting_photos)}
+    context 'interesting_photos' do
+      let(:fixture) {:interesting_photos}
+      it_behaves_like "a flickraw fixture"
+    end
+
+    specify {subject.should respond_to(:author_photos)}
+    context "author_photos" do
+      let(:fixture) {:author_photos}
+      it_behaves_like "a flickraw fixture"
+    end
+
+    specify {subject.should respond_to(:photo_size)}
+    context "photo_size" do
+      let(:fixture) {:photo_size}
+      it_behaves_like "a flickraw fixture"
+    end
+
+    specify {subject.should respond_to(:photo_sizes)}
+    context "photo_sizes" do
+      let(:fixture) {:photo_sizes}
+      it_behaves_like "a flickraw fixture"
+    end
+  end
+
+end
+
+
+
+
+
+

data/spec/base/flickraw/custom_clone_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe APP::CustomClone do
+  let(:fixtures){APP::Fixtures.new}
+
+  let(:photo){fixtures.photo}
+  let(:photos){fixtures.photos}
+  let(:photo_details){fixtures.photo_details}
+  let(:photo_sizes){fixtures.photo_sizes}
+  let(:photo_size){fixtures.photo_size}
+
+  # helper test method that check the ids of all object containted in a
+  # => FlickRaw::Response/ResponseList objects
+  def same_ids?(object,other)
+    case object
+    when FlickRaw::Response then same_ids?(object.instance_eval('@h'), other.instance_eval('@h'))
+    when Fixnum then nil
+    when String then object.__id__ == other.__id__
+    when Array then object.each_with_index.map do |value,index|
+        same_ids?(value,other[index])
+      end.keep_if do |value|
+        !value.nil?
+      end.inject(true) do |previous,current|
+        previous && current
+      end
+    when Hash then object.keys.map do |key|
+        same_ids?(object[key],other[key])
+      end.keep_if do |value|
+        !value.nil?
+      end.inject(true) do |previous,current|
+        previous && current
+      end
+    end
+  end
+
+  context "clone" do
+    shared_examples_for "cloning any flickraw response" do
+      it "returns clone with distinct ids from original object" do
+        other = subject.clone
+        same_ids?(subject,other).should be_false
+      end
+    end
+
+    context "cloning photo flickraw response" do
+      let(:subject){ photo}
+      it_behaves_like "cloning any flickraw response"
+    end
+
+    context "cloning photos flickraw responseList" do
+      let(:subject) { photos }
+      it_behaves_like "cloning any flickraw response"
+    end
+
+    context "cloning photo_details flickraw responseList" do
+      let(:subject) {photo_details}
+      it_behaves_like "cloning any flickraw response"
+    end
+
+    context "cloning photo_sizes flickraw responseList" do
+      let(:subject) { photo_sizes }
+      it_behaves_like "cloning any flickraw response"
+    end
+
+    context "cloning photo_size responseList" do
+      let(:subject) {photo_size}
+      it_behaves_like "cloning any flickraw response"
+    end
+  end
+
+end

data/spec/base/flickraw/custom_compare_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe APP::CustomCompare do
+  let(:fixtures){APP::Fixtures.new}
+
+  let(:photo){fixtures.photo}
+  let(:photos){fixtures.photos}
+  let(:photo_details){fixtures.photo_details}
+  let(:photo_sizes){fixtures.photo_sizes}
+  let(:photo_size){fixtures.photo_size}
+
+  shared_examples_for "flickraw response for ==" do
+    it "should be equal to itself" do
+      subject.should == subject
+    end
+    it "should not be equal to nil" do
+      subject.should_not == nil
+    end
+    it "should be equal to clone of itself" do
+      subject.should == subject.clone
+    end
+    it "should not equal a different class" do
+      subject.should_not == [1,2,3,4]
+    end
+    it "should not eq another response" do
+      subject.should_not == other
+    end
+  end
+
+  context "instance methods" do
+    context "#==" do
+      context "photo flickraw response" do
+        let(:subject){photo}
+        let(:other){photo_details}
+
+        it_behaves_like  "flickraw response for =="
+
+        it "returns false when object is compared with object that is slightly different" do
+          other = subject.clone
+          other.stub(:title).and_return(Faker::Lorem.sentence(3))
+          subject.should_not == other
+        end
+      end
+
+      context "photos flickraw responselist" do
+        let(:subject){photos}
+        let(:other){photo_details}
+    
+        it_behaves_like "flickraw response for =="
+
+        it "returns false when object is compared with object that is slightly different" do
+          other = subject.clone
+          other.stub(:total).and_return('123454321')
+          subject.should_not == other
+        end
+      end
+
+      context "photo_details flickraw response" do
+        let(:subject){photo_details}
+        let(:other){photo_sizes}
+
+        it_behaves_like "flickraw response for =="
+
+        it "returns false when object is compared with object that is slightly different" do
+          other = subject.clone
+          subject.stub(:farm).and_return(123421)
+          subject.should_not == other
+        end
+      end
+
+      context "photo_sizes response list" do
+        let(:subject){photo_sizes}
+        let(:other){photo_details}
+
+        it_behaves_like "flickraw response for =="
+
+        it "returns false when object is compared with object that is slightly different" do
+          other = subject.clone
+          other.stub(:canprint).and_return(1234321)
+          subject.should_not == other
+        end
+      end
+
+      context "photo_size response" do
+        let(:subject){photo_size}
+        let(:other){photo_details}
+
+        it_behaves_like "flickraw response for =="
+
+        it "returns false when object is compared with object that is slightly different" do
+          other = subject.clone
+          other.stub(:width).and_return(1234321)
+          subject.should_not == other
+        end
+      end
+    end
+  end
+end

data/spec/base/flickraw/custom_marshal_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe APP::CustomMarshal do
+  let(:klass) {APP::CustomMarshal}
+  let(:helpers) {APP::Helpers}
+  let(:fixtures) {APP::Fixtures.new}
+
+  shared_examples_for "marshalling and unmarshalling flickraw objects" do
+    it "should properly marshal/unmarshal Photos object" do
+      marshalled = Marshal.load(Marshal.dump(subject))
+      helpers.equivalent?(subject,marshalled).should be_true
+    end
+  end
+  
+  context "intance methods" do
+    context "flickraw fixtures" do
+      context "#marshal and #unmarshal" do
+        context "fixture: photos" do
+          let(:subject){fixtures.photos}
+          it_behaves_like "marshalling and unmarshalling flickraw objects"
+        end
+
+        context "fixture: photo_sizes" do
+          let(:subject){fixtures.photo_sizes}
+          it_behaves_like "marshalling and unmarshalling flickraw objects"
+        end
+
+        context "fixture: photo_details" do
+          let(:subject){fixtures.photo_details}
+          it_behaves_like "marshalling and unmarshalling flickraw objects"
+        end
+
+        context "fixture: photo" do
+          let(:subject){fixtures.photo}
+          it_behaves_like "marshalling and unmarshalling flickraw objects"
+        end
+
+        context "fixture: interesting_photos" do
+          let(:subject){fixtures.interesting_photos}
+          it_behaves_like "marshalling and unmarshalling flickraw objects"
+        end
+      end
+    end
+  end
+end

data/spec/base/helpers_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe APP::Helpers do
+  let(:klass) {APP::Helpers}
+  let(:fixtures) {APP::Fixtures.new}
+
+  context "class methods" do
+
+    specify {klass.should respond_to(:extension)}
+    context 'extension' do
+      it "returns expected extension: .marshal" do
+        klass.extension.should == '.marshal'
+      end
+    end
+
+    specify {klass.should respond_to(:fname_fixture)}
+    context "fname_fixture" do
+      it "returns correct fixture file name with symbol argument" do
+        expected_fname = 'sample_file' + klass.extension
+        klass.fname_fixture(:sample_file).should == expected_fname
+      end
+      it "raises an error when file name is a string" do
+        expect {klass.fname_fixture('sample_file')}.to raise_error
+      end
+    end
+
+    specify {klass.should respond_to(:equivalent?)}
+    context "equivalent?" do
+      it "returns true when photo_detail object compared to itself" do
+        klass.should be_equivalent(fixtures.photo_details,fixtures.photo_details)
+      end
+      it "returns true when photo_sizes object is compared to itself" do
+        klass.should be_equivalent(fixtures.photo_sizes,fixtures.photo_sizes)
+      end
+      it "returns true when same photo object is compared to itself" do
+        klass.should be_equivalent(fixtures.photos,fixtures.photos)
+      end
+      it "returns false when photo_details object is compared to photo object" do
+        klass.should_not be_equivalent(fixtures.photo_details, fixtures.photos.first)
+      end
+      it "returns false when photo_sizes object is compared to photo_details object" do
+        klass.should_not be_equivalent(fixtures.photo_sizes,fixtures.photo_details)
+      end
+    end
+
+    specify {klass.should respond_to(:dump)}
+    specify {klass.should respond_to(:load)}
+    context "dump/load behavior" do
+      it "dumps and loads an object without losing data" do
+        begin
+          fname = "/tmp/#{Time.now}_#{Random.rand}"
+          expected = [Random.rand,Random.rand]
+          klass.dump(expected,fname)
+          actual = klass.load(fname)
+          actual.should == expected
+        ensure
+          File.delete fname
+        end
+      end
+    end
+
+  end
+end

data/spec/base/stubs_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe APP::Stubs do
+  let(:klass) {APP::Stubs}
+  let(:fixtures) {APP::Fixtures.new}
+
+  context "class methods" do
+    
+    specify{klass.should respond_to(:stub_flickr)}
+    context "stub_flickr" do
+      before(:each) do
+        klass.stub_flickr
+      end
+      it "stubs flickr.photos.search" do
+        flickr.photos.search(:tags => 'france').should == fixtures.photos
+      end
+      it "stubs flickr.photos.getSizes" do
+        flickr.photos.getSizes(:photo_id => '2121', :secret => '123abc').should == fixtures.photo_sizes
+      end
+      it "stubs flickr.photos.getInfo" do
+        flickr.photos.getInfo(:photo_id => '2121', :secret => '123abc').should == fixtures.photo_details
+      end
+      it "stubs flickr.interestingness.getList" do
+        flickr.interestingness.getList.should == fixtures.interesting_photos
+      end
+    end
+
+    specify {klass.should respond_to(:stub_search)}
+    context "stub_search: stubs for flickr.photos.search" do
+      before(:each) do
+        klass.stub_search
+      end     
+      it "raises error when no options provided" do
+        expect {
+          flickr.photos.search
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.search' - Parameterless searches have been disabled. Please use flickr.photos.getRecent instead./
+        )
+      end
+      it "raises when non-Hash option provided" do
+        expect {
+          flickr.photos.search([])
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.search' - Parameterless searches have been disabled. Please use flickr.photos.getRecent instead./
+        )
+      end
+      it "raises error when neither :photo nor :user_id given" do
+        expect {
+          flickr.photos.search(:per_page => '3', :license => '4' )
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.search' - Parameterless searches have been disabled. Please use flickr.photos.getRecent instead./
+        )
+      end
+      it "returns default photos fixture when :tags option given with non-garbage value" do
+        flickr.photos.search(:tags => "france").should == fixtures.photos
+      end
+      it "returns empty photos when :tags option given with garbage value" do
+        flickr.photos.search(:tags => "garbage").should == fixtures.empty_photos
+      end
+      it "returns author photo fixture when :user_id option given with non-garbage option" do
+        flickr.photos.search(:user_id => '23@393').should == fixtures.author_photos
+      end
+      it "returns empty photos when :user_id is garbage" do
+        flickr.photos.search(:user_id => 'garbage').should == fixtures.empty_photos
+      end
+      it "returns :author_photos when both :tags and :author_id provided with non-garbage option" do
+        flickr.photos.search(:user_id => '23@23', :tags => '23@23').should == fixtures.author_photos
+      end
+      it "returns empty_photos when :tags is garbage and :author_id is non-garbage" do
+        flickr.photos.search(:author_id => '23@393', :tags => 'garbage').should == fixtures.empty_photos
+      end
+      it "returns empty_photos when :author_id is garbage and :tags is non-garbage" do
+        flickr.photos.search(:user_id=> 'garbage', :tags => 'france').should == fixtures.empty_photos
+      end
+      it "returns :empty when both :author_id and :tags is garbage" do
+        flickr.photos.search(:user_id=>'garbage',:tags => 'garbage').should == fixtures.empty_photos
+      end
+    end
+
+
+    specify {klass.should respond_to(:stub_getInfo)}
+    context "stub_getInfo: which stubs flickr.photos.getInfo" do
+      before(:each) do
+        klass.stub_getInfo
+      end
+      it "raises error when no arguments provided" do
+        expect { flickr.photos.getInfo.should }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getInfo' - Photo not found/
+        )
+      end
+      it "raises error when improper photo_id provided" do
+        expect { flickr.photos.getInfo(:photo_id => 'garbage').should }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getInfo' - Photo "garbage" not found \(invalid ID\)/
+        )
+      end
+      it "raises error when non-hash option provided" do
+        expect { flickr.photos.getInfo([]).should }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getInfo' - Photo not found/
+        )
+      end
+      it "raises photo details fixture when photo_id and secret given" do
+        flickr.photos.getInfo(:secret => 'b5da82cd4e', :photo_id => '51028174').should == fixtures.photo_details
+      end
+      it "raises photo details fixture when  photo_id and no secret given" do
+        flickr.photos.getInfo(:photo_id => '51028174').should == fixtures.photo_details
+      end
+    end
+
+    specify {klass.should respond_to(:stub_getSizes)}
+    context "stub_getSizes: which stubs flickr.photos.getSizes" do
+      before(:each) do
+        klass.stub_getSizes
+      end
+      it "raises error when no options given" do
+        expect {
+          flickr.photos.getSizes
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getSizes' - Photo not found/
+        )
+      end
+      it "raises error when non-hash given" do
+        expect {
+          flickr.photos.getSizes []
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getSizes' - Photo not found/
+        )
+      end
+      it "raises error when garbage given as photo_id" do
+        expect {
+          flickr.photos.getSizes :photo_id => 'garbage'
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /'flickr.photos.getSizes' - Photo not found/
+        )
+      end
+      it "returns photo sizes fixture when option given" do
+        flickr.photos.getSizes(:secret => '3c4374b19e', :photo_id => "5102817422").should == fixtures.photo_sizes
+      end
+    end
+
+    specify {klass.should respond_to(:stub_interestingness)}
+    context "stub_interestingness: stubs  flickr.interestingness.getList" do
+      before(:each) do
+        klass.stub_interestingness
+      end
+      it "returns interesting fixture when no option given" do
+        flickr.interestingness.getList.should == fixtures.interesting_photos
+      end
+      it "returns interesting fixture with non-hash option argument" do
+        flickr.interestingness.getList([]).should == fixtures.interesting_photos
+      end
+      it "returns interesting fixture if hash-option with :date key provided" do
+        flickr.interestingness.getList(:tags => 'hello').should == fixtures.interesting_photos
+      end
+      it "raises error if invalid date provided" do
+        expect {
+          flickr.interestingness.getList(:date => 'garbage')
+        }.to raise_error(
+          FlickRaw::FailedResponse,
+          /Not a valid date string/
+        )
+      end
+      it "returns empty string if 2001-01-01 given" do
+        flickr.interestingness.getList(:date => '2000-01-01').should == fixtures.empty_photos
+      end
+      it "returns photo details fixture when option given" do
+        flickr.interestingness.getList(:date=> '2010-10-10').should == fixtures.interesting_photos
+      end
+    end
+
+  end
+end

data/spec/base/version_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe APP::VERSION do
+  subject{APP::VERSION}
+
+  context "constants" do
+    context "VERSION" do
+      it "returns expected version number" do
+        expected_version = File.read(File.expand_path("../../../VERSION", __FILE__)).strip
+        subject.should == expected_version
+      end
+    end
+  end
+
+end

data/spec/fixtures/expected_methods.marshal

@@ -0,0 +1,17 @@
+U:OpenStruct{
+pages:perpage:
+total:
+photo:flickr_type:empty_photos[;;;	;
+;;:interesting_photos[;;;	;
+;;:author_photos[;;;	;
+;;;[:id:
+owner:secret:server:	farm:
+title:
+dates:
+views:editability:
+usage:
+notes:	tags:
+media;:photo_sizes[
+:canblog:
+label:
+width:height:source:url;,;

data/spec/models/helpers_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe APP::Models::Helpers do
+  let(:klass) {APP::Models::Helpers}
+  context "class methods" do
+
+    specify {klass.should respond_to(:array_accessor_methods)}
+    context "array_accessor_methods" do
+      it "returns expected array methods" do
+        klass.array_accessor_methods.sort.should ==  [:[], :at,:fetch, :first, :last,:each,
+                                                                    :each_index, :reverse_each,:length, :size,
+                                                                    :empty?, :find_index, :index,:rindex, :collect,
+                                                                    :map, :select, :keep_if, :values_at].sort
+      end
+    end
+
+    specify {klass.should respond_to(:possible_sizes)}
+    context "possible_sizes" do
+      it "returns expected array of possible image sizes" do
+        klass.possible_sizes.should == [:square, :thumbnail, :small, :medium,
+                                                              :medium_640, :large, :original]
+      end
+    end
+  end
+end