carrierwave_direct 0.0.1

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'carrierwave_direct'
+require 'json'
+require 'timecop'
+Dir[ File.dirname(__FILE__) << "/support/**/*.rb"].each {|file| require file }
+

data/spec/support/carrier_wave_config.rb

@@ -0,0 +1,9 @@
+CarrierWave.configure do |config|
+  config.fog_credentials = {
+    :provider               => 'AWS',
+    :aws_access_key_id      => 'AWS_ACCESS_KEY_ID',
+    :aws_secret_access_key  => 'AWS_SECRET_ACCESS_KEY'
+  }
+  config.fog_directory = 'AWS_FOG_DIRECTORY' # bucket name
+end
+

data/spec/support/direct_uploader.rb

@@ -0,0 +1,4 @@
+class DirectUploader < CarrierWave::Uploader::Base
+  include CarrierWaveDirect::Uploader
+end
+

data/spec/support/form_builder_helpers.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'action_view'
+require 'action_view/template'
+
+require 'carrierwave_direct/form_builder'
+require 'carrierwave_direct/action_view_extensions/form_helper'
+
+module FormBuilderHelpers
+  include ActionView::Helpers::FormHelper
+  include CarrierWaveDirect::ActionViewExtensions::FormHelper
+  include ActionView::Context
+  include ActionController::RecordIdentifier
+
+  include ViewHelpers
+
+  def direct_uploader
+    defined?(super) ? super : @direct_uploader ||= MountedClass.new.video
+  end
+
+  def self.included(base)
+    DirectUploader.send(:include, ActiveModel::Conversion)
+    DirectUploader.extend ActiveModel::Naming
+  end
+
+  def protect_against_forgery?
+    false
+  end
+
+  def form(&block)
+    blk = block_given? ? block : Proc.new {|f|}
+    direct_upload_form_for(direct_uploader, &blk)
+  end
+
+end
+

data/spec/support/global_helpers.rb

@@ -0,0 +1,6 @@
+GUID_REGEXP = "[a-f\\d\\-]+"
+
+def sample(data)
+  SAMPLE_DATA[data]
+end
+

data/spec/support/model_helpers.rb

@@ -0,0 +1,80 @@
+module ModelHelpers
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def it_should_be_accessible(name, sample_data, options = {})
+      describe "when initialized with .new(:#{name} => '#{sample_data}')" do
+
+        let(:accessor_value) do
+          subject.class.send(:new, { name => sample_data }).send(name)
+        end
+
+        if options[:accessible]
+          if options[:accessible] == true
+            it "should == '#{sample_data}'" do
+              accessor_value.should == sample_data
+            end
+          else
+            it "##{options[:accessible].keys.first} should be #{options[:accessible].values.first}" do
+              subject.send(options[:accessible].keys.first).should == options[:accessible].values.first
+            end
+          end
+        else
+          it "should be nil" do
+            accessor_value.should be_nil
+          end
+        end
+      end
+    end
+
+    def it_should_delegate(name, options = {})
+      sample_data = "sample_#{name.to_s}"
+      delegation_object, delegation_method = options[:to].split("#")
+
+      describe "##{name} = '#{sample_data}'" do
+        it "should set the #{delegation_object}'s #{delegation_method}" do
+          subject.send("#{name}=", sample_data)
+          subject.send(delegation_object).send(delegation_method).should == sample_data
+        end
+      end
+
+      describe "##{name}" do
+        it "should return the #{delegation_method} from the #{delegation_object}" do
+          subject.send(delegation_object).send("#{delegation_method}=", sample_data)
+          subject.send(name).should == sample_data
+        end
+
+        it_should_be_accessible(name, sample_data, options)
+      end
+    end
+
+    def it_should_have_accessor(name, options = {})
+      if name.is_a?(Hash)
+        key = name.keys.first
+        sample_data = name[key]
+        name = key
+      else
+        sample_data = "sample_#{name.to_s}"
+      end
+
+      it "should respond to ##{name}=" do
+        subject.should respond_to("#{name}=")
+      end
+
+      describe "##{name}" do
+        context "where the #{name} is set to '#{sample_data}'" do
+          before { subject.send("#{name}=", sample_data) }
+
+          it "should == '#{sample_data}'" do
+            subject.send(name).should == sample_data
+          end
+        end
+
+        it_should_be_accessible(name, sample_data, options)
+      end
+    end
+  end
+end
+

data/spec/support/mounted_class.rb

@@ -0,0 +1,6 @@
+class MountedClass
+  extend CarrierWave::Mount
+  extend CarrierWaveDirect::Mount
+  mount_uploader :video, DirectUploader
+end
+

data/spec/support/uploader_helpers.rb

@@ -0,0 +1,8 @@
+module UploaderHelpers
+  include CarrierWaveDirect::Test::Helpers
+
+  def sample_key(options = {})
+    super(MountedClass.new.video, options)
+  end
+end
+

data/spec/support/view_helpers.rb

@@ -0,0 +1,45 @@
+require 'capybara/rspec'
+
+module ViewHelpers
+  include Capybara::RSpecMatchers
+
+  def parent_selector
+    defined?(super) ? super : @parent_selector ||= []
+  end
+
+  def have_parent_selector(options = {})
+    have_selector(:xpath, parent_selector_xpath, options)
+  end
+
+  def parent_selector_xpath
+    xpath = parent_selector.join("/")
+    xpath = ".//#{xpath}" unless xpath[0..2] == ".//"
+    xpath
+  end
+
+  def submit_to(options = {})
+    xpath_attributes = to_xpath_attributes(options)
+    parent_selector << "form[#{xpath_attributes}]"
+    have_parent_selector
+  end
+
+  def to_xpath_attributes(options = {})
+    attributes = []
+
+    options.each do |key, value|
+      attributes << ((value == false) ? "not(@#{key})" : "@#{key}='#{value}'")
+    end
+
+    attributes.join(" and ")
+  end
+
+  def have_input(resource_name, input, options = {})
+    options[:type] ||= input
+    options[:id] ||= "#{resource_name}_#{input}"
+    options[:name] ||= "#{resource_name}[#{input}]"
+    options[:required] ||= "required" unless options[:required] == false
+    parent_selector << "input[#{to_xpath_attributes(options)}]"
+    have_parent_selector
+  end
+end
+

data/spec/test/capybara_helpers_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe CarrierWaveDirect::Test::CapybaraHelpers do
+  class ExampleSpec
+    include CarrierWaveDirect::Test::CapybaraHelpers
+  end
+
+  let(:subject) { ExampleSpec.new }
+  let(:page) { mock("Page").as_null_object }
+  let(:selector) { mock("Selector") }
+
+  def stub_page
+    subject.stub(:page).and_return(page)
+  end
+
+  def find_element_value(css, value)
+    page.stub(:find).with(css).and_return(selector)
+    selector.stub(:value).and_return(value)
+  end
+
+  describe "#attach_file_for_direct_upload" do
+    context "'path/to/file.ext'" do
+      it "should attach a file with the locator => 'file'" do
+        subject.should_receive(:attach_file).with("file", "path/to/file.ext")
+        subject.attach_file_for_direct_upload "path/to/file.ext"
+      end
+    end
+  end
+
+  describe "#upload_directly" do
+    let(:uploader) { DirectUploader.new }
+
+    def upload_directly(options = {})
+      options[:button_locator] ||= ""
+      button_locator = options.delete(:button_locator)
+      subject.upload_directly(uploader, button_locator, options)
+    end
+
+    def stub_common
+      stub_page
+      find_element_value("input[@name='success_action_redirect']", "http://example.com")
+      subject.stub(:visit)
+    end
+
+    before do
+      subject.stub(:click_button)
+    end
+
+    shared_examples_for "submitting the form" do
+      let(:options) { {} }
+
+      it "should submit the form" do
+        subject.should_receive(:click_button).with("Upload!")
+        upload_directly(options.merge(:button_locator => "Upload!"))
+      end
+    end
+
+    shared_examples_for ":success => false" do
+      let(:options) { { :success => false } }
+
+      it "should not redirect" do
+        subject.should_not_receive(:visit)
+        upload_directly(options)
+      end
+    end
+
+    context "passing no options" do
+      before do
+        stub_common
+        subject.stub(:find_key).and_return("upload_dir/guid/$filename")
+        subject.stub(:find_upload_path).and_return("path/to/file.ext")
+      end
+
+      it_should_behave_like "submitting the form"
+
+      it "should redirect to the page's success_action_redirect url" do
+        subject.should_receive(:visit).with(/^http:\/\/example.com/)
+        upload_directly
+      end
+
+      context "the redirect url's params" do
+        it "should include the bucket name" do
+          subject.should_receive(:visit).with(/bucket=/)
+          upload_directly
+        end
+
+        it "should include an etag" do
+          subject.should_receive(:visit).with(/etag=/)
+          upload_directly
+        end
+
+        it "should include the key derived from the form" do
+          subject.should_receive(:visit).with(/key=upload_dir%2Fguid%2Ffile.ext/)
+          upload_directly
+        end
+      end
+    end
+
+    context "with options" do
+      context ":redirect_key => 'some redirect key'" do
+        before do
+          stub_common
+        end
+
+        context "the redirect url's params" do
+          it "should include the key from the :redirect_key option" do
+            subject.should_receive(:visit).with(/key=some\+redirect\+key/)
+            upload_directly(:redirect_key => "some redirect key")
+          end
+        end
+      end
+
+      context ":success => false" do
+        let(:options) { { :success => false } }
+
+        it_should_behave_like "submitting the form" do
+          let(:options) { { :success => false } }
+        end
+
+        it_should_behave_like ":success => false"
+      end
+
+      context ":fail => true" do
+        it_should_behave_like "submitting the form" do
+          let(:options) { { :fail => true } }
+        end
+
+        it_should_behave_like ":success => false" do
+          let(:options) { { :fail => true } }
+        end
+      end
+    end
+  end
+
+  describe "#find_key" do
+    before do
+      stub_page
+      find_element_value("input[@name='key']", "key")
+    end
+
+    it "should try to find the key on the page" do
+      subject.find_key.should == "key"
+    end
+  end
+
+  describe "#find_upload_path" do
+    before do
+      stub_page
+      find_element_value("input[@name='file']", "upload path")
+    end
+
+    it "should try to find the upload path on the page" do
+      subject.find_upload_path.should == "upload path"
+    end
+  end
+
+end
+

data/spec/test/helpers_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe CarrierWaveDirect::Test::Helpers do
+  include CarrierWaveDirect::Test::Helpers
+
+  describe "#sample_key" do
+    context "passing an instance of DirectUploader mounted as a video" do
+      let(:direct_uploader) { MountedClass.new.video }
+
+      context "where its extension white list returns" do
+
+        shared_examples_for "returning the default extension" do
+          it "should return '*/guid/filename.extension'" do
+            sample_key(direct_uploader).should =~ /#{GUID_REGEXP}\/filename\.extension$/
+          end
+        end
+
+        context "['exe', 'bmp']" do
+          before do
+            direct_uploader.stub(:extension_white_list).and_return(%w{exe bmp})
+          end
+
+          it "should return '*/guid/filename.exe'" do
+            sample_key(direct_uploader).should =~ /#{GUID_REGEXP}\/filename\.exe$/
+          end
+        end
+
+        context "[]" do
+          before do
+            direct_uploader.stub(:extension_white_list).and_return([])
+          end
+
+          it_should_behave_like "returning the default extension"
+        end
+
+        context "nil" do
+          before do
+            direct_uploader.stub(:extension_white_list).and_return(nil)
+          end
+
+          it_should_behave_like "returning the default extension"
+        end
+
+      end
+
+      context "with no options" do
+        it "should return '*/guid/filename.extension'" do
+          sample_key(
+            direct_uploader,
+          ).should =~ /#{GUID_REGEXP}\/filename\.extension$/
+        end
+      end
+
+      context "with options" do
+        shared_examples_for "an invalid key" do
+          it "should return 'filename.extension'" do
+            key_parts = sample_key(direct_uploader, options).split("/")
+            key_parts.pop
+            key_parts.last.should_not =~ /^#{GUID_REGEXP}$/
+          end
+        end
+
+        shared_examples_for "a custom filename" do
+          it "should return '*/guid/some_file.reg'" do
+            sample_key(direct_uploader, options).should =~ /#{GUID_REGEXP}\/some_file\.reg$/
+          end
+        end
+
+        context ":invalid => true" do
+          it_should_behave_like "an invalid key" do
+            let(:options) { { :invalid => true } }
+          end
+        end
+
+        context ":valid => false" do
+          it_should_behave_like "an invalid key" do
+            let(:options) { { :valid => false } }
+          end
+        end
+
+        context ":base => 'upload_dir/porno/movie/${filename}'" do
+          it "should return 'upload_dir/porno/movie/guid/filename.extension'" do
+            sample_key(
+              direct_uploader,
+              :base => "upload_dir/porno/movie/${filename}"
+            ).should == "upload_dir/porno/movie/filename.extension"
+          end
+        end
+        context ":filename => 'some_file.reg'" do
+          it_should_behave_like "a custom filename" do
+            let(:options) { { :filename => "some_file.reg" } }
+          end
+        end
+        context ":filename => 'some_file', :extension => 'reg'" do
+          it_should_behave_like "a custom filename" do
+            let(:options) { { :filename => "some_file", :extension => "reg" } }
+          end
+        end
+      end
+    end
+  end
+end
+