flickr_offline_gallery 0.0.2 → 0.0.3

data/spec/flickr_offline_gallery/gallery_generator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+
+  describe GalleryGenerator do
+    subject!(:photoset) do
+      VCR.use_cassette('photoset') do
+        Photoset.new("72157639475533743",
+                     :output_path => SPEC_TMP_DIR)
+      end
+    end
+
+    subject(:generator) { described_class.new(photoset) }
+
+    it "Should render a photoset gallery" do
+      VCR.use_cassette('image_downloads') do
+        generator.render_photoset("medium")
+      end
+      expect(Dir.glob(File.join(SPEC_TMP_DIR, "**", "*")).map do |path|
+        path.sub(SPEC_TMP_DIR, '')
+      end).to     eq(["/flickr-offline-gallery-specs",
+                      "/flickr-offline-gallery-specs/10440808526.html",
+                      "/flickr-offline-gallery-specs/10440808526.jpg",
+                      "/flickr-offline-gallery-specs/11224643544.html",
+                      "/flickr-offline-gallery-specs/11224643544.jpg",
+                      "/flickr-offline-gallery-specs/11439134074.html",
+                      "/flickr-offline-gallery-specs/11439134074.jpg",
+                      "/flickr-offline-gallery-specs/9579531199.html",
+                      "/flickr-offline-gallery-specs/9579531199.jpg",
+                      "/flickr-offline-gallery-specs.html"])
+    end
+
+  end
+
+end

data/spec/flickr_offline_gallery/path_manager_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe PathManager do
+    let(:base_path) { "/tmp/galleries" }
+    let(:slug)      { "holiday-photos" }
+    let(:photo_id)  { "1235645" }
+    subject(:path_manager) { described_class.new(base_path, slug) }
+
+    it "should have an index page named the same as the slug" do
+      expect(path_manager.index_page).to eq( "/tmp/galleries/holiday-photos.html")
+    end
+
+    it "should put photos and their pages in a common folder" do
+      expect(path_manager.photo_output_path).to eq( "/tmp/galleries/holiday-photos")
+      expect(path_manager.full_path_for(photo_id, :jpg)).to eq( "/tmp/galleries/holiday-photos/1235645.jpg")
+      expect(path_manager.full_path_for(photo_id, :html)).to eq("/tmp/galleries/holiday-photos/1235645.html")
+    end
+
+    it "should give relative links for the index page" do
+      expect(path_manager.relative_path_for(photo_id, :jpg)).to eq( "holiday-photos/1235645.jpg")
+      expect(path_manager.relative_path_for(photo_id, :html)).to eq("holiday-photos/1235645.html")
+    end
+
+    it "should give filenames for the photo page" do
+      expect(path_manager.filename_for_photo(photo_id, :jpg)).to eq( "1235645.jpg")
+    end
+
+    it "should give 'back' links back to the index page for photo pages" do
+      expect(path_manager.back_to_index).to eq( "../holiday-photos.html")
+    end
+
+  end
+end

data/spec/flickr_offline_gallery/photo_page_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe PhotoPage do
+
+    let(:photo_id) { "9579531199" }
+
+    let(:horrible_raw_flickr_junk) do
+      VCR.use_cassette('photo_with_janky_metadata') do
+        FlickrAPI.get_photo_info(photo_id)
+      end
+    end
+
+    let(:path_manager) { double("PathManager",
+                               :back_to_index => "foo",
+                               :filename_for_photo => "bar"
+                               ) }
+    let(:photoset_id) { "ffff" }
+
+    let!(:photo) {
+
+      VCR.use_cassette('full_photo_sizes_with_janky_metadata') do
+        Photo.new(horrible_raw_flickr_junk,
+                            :photoset_id => photoset_id,
+                            :path_manager => path_manager)
+      end
+    }
+
+    subject!(:photo_page) {
+      described_class.new(photo)
+    }
+
+    it "should be utf-8" do
+      expect(photo_page.render).to include(%(<meta http-equiv="Content-Type" content="text/html; charset=utf-8">))
+    end
+
+    it "should html encode titles/etc" do
+      expect(photo_page.render).to include(%(alt="This &quot;néeds&quot; sóme &#39;fü**ed up çhara&quot;cterş"))
+      expect(photo_page.render).to include(%(title="This &quot;néeds&quot; sóme &#39;fü**ed up çhara&quot;cterş by Lucas the nomad, on Flickr"))
+    end
+  end
+end

data/spec/flickr_offline_gallery/photo_size_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe PhotoSize do
+
+    subject!(:size) {
+      VCR.use_cassette('photo_sizes') do
+        described_class.new(FlickrAPI.get_photo_sizes("10440808526")[2])
+      end
+    }
+
+    it "should should know its label" do
+      expect(size.label).to eq("Thumbnail")
+    end
+
+    it "should should know its height" do
+      expect(size.height).to eq("75")
+    end
+
+    it "should should know its width" do
+      expect(size.width).to eq("100")
+    end
+
+    it "should should know its url" do
+      expect(size.url).to eq("https://farm8.staticflickr.com/7402/10440808526_c3fd515635_t.jpg")
+    end
+
+    it 'should know its filename friendly key' do
+      expect(size.key).to eq("thumbnail")
+    end
+  end
+end

data/spec/flickr_offline_gallery/photo_sizes_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe PhotoSizes do
+
+    let(:raw_flickr_response) do
+      VCR.use_cassette('photo_sizes') do
+        FlickrAPI.get_photo_sizes("10440808526")
+      end
+    end
+
+    subject!(:sizes) { described_class.new(raw_flickr_response) }
+
+    it "should allow access like an array" do
+      expect(sizes["thumbnail"]).to be_a(PhotoSize)
+      expect(sizes["thumbnail"].label).to eq("Thumbnail")
+    end
+
+    it "should respond to #each" do
+      expect(sizes).to respond_to(:each)
+    end
+  end
+end

data/spec/flickr_offline_gallery/photo_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe Photo do
+
+    let(:photo_id) { "10440808526" }
+
+    let(:horrible_raw_flickr_junk) do
+      VCR.use_cassette('photo') do
+        FlickrAPI.get_photo_info(photo_id)
+      end
+    end
+
+    let(:path_manager) { double("PathManager") }
+    let(:photoset_id) { "ffff" }
+
+    subject!(:photo) {
+
+      VCR.use_cassette('full_photo_sizes') do
+        described_class.new(horrible_raw_flickr_junk,
+                            :photoset_id => photoset_id,
+                            :path_manager => path_manager)
+      end
+    }
+
+    it "should have a title" do
+      expect(photo.title).to eq("Giant hippo yawn")
+    end
+
+    it "should have a url" do
+      expect(photo.url).to eq("https://www.flickr.com/photos/lucasthenomad/10440808526/in/set-ffff")
+    end
+
+    it "should have a base_url" do
+      expect(photo.base_url).to eq("https://www.flickr.com/photos/lucasthenomad/10440808526/")
+    end
+
+    context "delegating path work to the path manager" do
+
+      it "should ask the path manager for its img_filename" do
+        path_manager.should_receive(:filename_for_photo).with(photo_id, :jpg)
+        photo.img_filename
+      end
+
+      it "should ask the path manager for its full_jpg_path" do
+        path_manager.should_receive(:full_path_for).with(photo_id, :jpg)
+        photo.full_jpg_path
+      end
+
+      it "should ask the path manager for its full_html_path" do
+        path_manager.should_receive(:full_path_for).with(photo_id, :html)
+        photo.full_html_path
+      end
+
+      it "should ask the path manager for its relative_jpg_path" do
+        path_manager.should_receive(:relative_path_for).with(photo_id, :jpg)
+        photo.relative_jpg_path
+      end
+
+      it "should ask the path manager for its relative_html_path" do
+        path_manager.should_receive(:relative_path_for).with(photo_id, :html)
+        photo.relative_html_path
+      end
+
+      it "should ask the path manager for its back_to_index_url" do
+        path_manager.should_receive(:back_to_index)
+        photo.back_to_index_url
+      end
+
+    end
+
+    it "should have sizes" do
+      expect(photo.sizes).to be_a(PhotoSizes)
+    end
+
+    it "should have a author" do
+      expect(photo.author).to eq("Lucas the nomad")
+    end
+
+  end
+end

data/spec/flickr_offline_gallery/photoset_downloader_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe PhotosetDownloader do
+
+    subject(:photoset_downloader) do
+        described_class.new(photoset, selected_size)
+    end
+    let(:selected_size) { :thumbnail }
+
+    let(:photoset) do
+      VCR.use_cassette('photoset') do
+        Photoset.new("72157639475533743",
+                    :output_path => SPEC_TMP_DIR)
+      end
+    end
+
+    it 'should download' do
+      VCR.use_cassette('photset_downloader_spec') do
+        photoset_downloader.download
+      end
+      expect(File.exist?(photoset.photos[0].full_jpg_path)).to be_true
+    end
+
+  end
+
+end

data/spec/flickr_offline_gallery/photoset_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+  describe Photoset do
+    subject(:photoset) do
+      VCR.use_cassette('photoset') do
+        described_class.new("72157639475533743",
+                           :output_path => SPEC_TMP_DIR)
+      end
+    end
+
+    it 'should have a username' do
+      expect(photoset.username).to eq("Lucas the nomad")
+    end
+
+    it 'should have a title' do
+      expect(photoset.title).to eq("flickr_offline_gallery specs")
+    end
+
+    it 'should have a slug' do
+      expect(photoset.slug).to eq("flickr-offline-gallery-specs")
+    end
+
+    it 'should have a photos' do
+      expect(photoset.photos.count).to eq(4)
+      expect(photoset.photos.first.title).to eq("Purdy lamps")
+    end
+
+    it "should have an index page filename" do
+      expect(photoset.index_page_filename).to eq("#{SPEC_TMP_DIR}/flickr-offline-gallery-specs.html")
+    end
+
+  end
+
+end

data/spec/flickr_offline_gallery/template_renderer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+module FlickrOfflineGallery
+  describe TemplateRenderer do
+    subject(:renderer) { described_class.new(template_name) }
+    let(:template_name) { "cool_template" }
+    let(:test_filename) { "tmp/template_renderer_spec.html" }
+    let(:template_contents) do <<-ERB
+                              This is <%= variable %>!
+                              ERB
+    end
+
+    it "should know where templates live" do
+      expect(renderer.template_directory).to eq(File.join(GEM_ROOT, "erb"))
+    end
+
+    it "should know what template to render" do
+      expect(renderer.template_path).to eq(File.join(renderer.template_directory, "#{template_name}.html.erb"))
+    end
+
+    it "should raise an error if the template is missing" do
+      File.should_receive(:exist?).and_return(false)
+      expect {
+        renderer.template_contents
+      }.to raise_error("Unknown template: #{renderer.template_path}")
+    end
+
+    it "should read in the correct template" do
+      File.stub(:exist? => true)
+      File.stub(:read => template_contents)
+      expect(renderer.template_contents).to eq(template_contents)
+    end
+
+    it "should render the template with the local variables" do
+      File.stub(:exist? => true)
+      File.stub(:read => template_contents)
+
+      expect(renderer.render_erb(:variable => "awesome").strip).to eq("This is awesome!")
+      expect(renderer.render_erb(:variable => "crappy").strip).to eq("This is crappy!")
+    end
+
+    it "should write the results of the render method to a file" do
+      FileUtils.rm_f(test_filename)
+
+      renderer.should_receive(:render).and_return(template_contents)
+
+      renderer.write_file(test_filename)
+      expect(File.read(test_filename)).to eq(template_contents)
+
+    end
+  end
+end

data/spec/flickr_offline_gallery/verbose_puts_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module FlickrOfflineGallery
+
+  describe 'VerbosePuts mixin' do
+    class TestPuts
+      include FlickrOfflineGallery::VerbosePuts
+    end
+
+    subject(:test_class) { TestPuts.new }
+
+    before do
+      @old_verbose = ENV["VERBOSE"]
+    end
+
+    after do
+      ENV["VERBOSE"] = @old_verbose
+    end
+
+    it "should puts if the env var VERBOSE is set" do
+      ENV["VERBOSE"] = 'true'
+      test_class.should_receive(:puts).with("test string")
+      test_class.verbose_puts "test string"
+    end
+
+    it "should not puts if the env var VERBOSE is not set" do
+      ENV["VERBOSE"] = nil
+      test_class.should_not_receive(:puts).with("test string")
+      test_class.verbose_puts "test string"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+GEM_ROOT = File.expand_path("../..", __FILE__)
+SPEC_TMP_DIR = File.join(GEM_ROOT, "tmp", "spec")
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.expect_with :rspec do |c|
+    # disable the `should` syntax...
+    c.syntax = :expect
+  end
+
+  config.before(:each) do
+    # clean out any created files between every test
+    FileUtils.rm_rf(SPEC_TMP_DIR)
+    FileUtils.mkdir_p(SPEC_TMP_DIR)
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require 'vcr'
+require 'pry-rescue'
+require 'flickraw'
+require 'flickr_offline_gallery'
+
+
+if  ENV["FLICKR_OFFLINE_GALLERY_SPEC_API_KEY"] && ENV["FLICKR_OFFLINE_GALLERY_SPEC_SHARED_SECRET"]
+  FlickRaw.api_key =       ENV["FLICKR_OFFLINE_GALLERY_SPEC_API_KEY"]
+  FlickRaw.shared_secret = ENV["FLICKR_OFFLINE_GALLERY_SPEC_SHARED_SECRET"]
+else
+  puts "you need to set FLICKR_OFFLINE_GALLERY_SPEC_API_KEY and FLICKR_OFFLINE_GALLERY_SPEC_SHARED_SECRET to test against live flickr"
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/vcr_cassettes'
+  c.hook_into :webmock
+
+  c.filter_sensitive_data('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx') do |interaction|
+    if auth_headers = interaction.request.headers["Authorization"]
+      auth_headers.first.sub(/.*oauth_nonce="([^"]*)".*/, "\\1")
+    else
+      nil
+    end
+  end
+
+  c.filter_sensitive_data('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx') do |interaction|
+    if auth_headers = interaction.request.headers["Authorization"]
+      auth_headers.first.sub(/.*oauth_consumer_key="([^"]*)".*/, "\\1")
+    else
+      nil
+    end
+  end
+
+  c.filter_sensitive_data('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx') do |interaction|
+    if auth_headers = interaction.request.headers["Authorization"]
+      auth_headers.first.sub(/.*oauth_signature="([^"]*)".*/, "\\1")
+    else
+      nil
+    end
+  end
+end
+
+# make FlickRaw work consistently with VCR
+#
+# FlickRaw keeps state in class instance variables and dynamically defines a
+# bunch of classes, which means request order is out unless this request is
+# done once up front. Nasty!
+VCR.use_cassette('init') do
+  FlickrOfflineGallery::FlickrAPI.instance
+end