siterest 0.1.0.pre1

data/lib/encoded_attachment/test/active_record_test.rb

@@ -0,0 +1,136 @@
+require 'test_helper'
+
+class ActiveRecordCreationTest < ActiveSupport::TestCase
+  load_schema
+
+  test "build, save and destroy model without exception" do
+    assert_nothing_raised {
+      @user = User.new(:name => 'John Doe', :avatar => File.open("test/fixtures/kitten.jpg"))
+      @user.save!
+      @user.destroy
+    }
+  end
+end
+
+class ActiveRecordUserWithEncodedAttachmentsTest < ActiveSupport::TestCase
+  load_schema
+  
+  setup do
+    @user = User.create(:name => 'John Doe', :avatar => File.open("test/fixtures/kitten.jpg"))
+  end
+  
+  teardown do
+    User.destroy_all
+  end
+  
+  test "should wrap to_xml methods" do
+    assert @user.methods.include?("to_xml_with_encoded_avatar"),    'Should include wrapped method'
+    assert @user.methods.include?("to_xml_without_encoded_avatar"), 'Should include unwrapped method'
+  end
+
+  test "should generate file tags" do
+    user_xml = Hash.from_xml(@user.to_xml)['user']
+    
+    assert       user_xml.has_key?('avatar'),                         'Should have avatar key'
+    assert_equal 'kitten.jpg', user_xml['avatar'].original_filename,  'Should set avatar filename'
+    assert_equal 'image/jpeg', user_xml['avatar'].content_type,       'Should set avatar content type'
+  end
+
+  test "should not generate file tags with :include_attachments => false" do
+    assert !(Hash.from_xml(@user.to_xml(:include_attachments => false))['user'].has_key?('avatar'))
+  end
+
+  test "file tag should be nil on new or destroyed records" do
+    @new_user = User.new(:name => 'John Doe', :avatar => File.open("test/fixtures/kitten.jpg"))
+    assert Hash.from_xml(@new_user.to_xml)['user']['avatar'].nil?
+  end
+  
+  test "file tag should be nil on destroyed records" do
+    @user.destroy
+    assert Hash.from_xml(@user.to_xml)['user']['avatar'].nil?
+  end
+
+  test "should copy file attributes from an existing record to a new one" do
+    @new_user = User.new.from_xml @user.to_xml
+
+    assert_equal 'John Doe', @new_user.name,                  'New user name should be the same'
+    assert       @new_user.avatar.file?,                      'New user should have a file'
+    assert       @new_user.save,                              'New user should save'
+    assert_equal 'kitten.jpg', @new_user.avatar_file_name,    'New user should have correct file name'
+    assert_equal 'image/jpeg', @new_user.avatar_content_type, 'New user should have correct content type'
+  end
+
+  test "should update attributes from one record to another" do
+    @other_user = User.create(:name => 'Bill Tapir', :avatar => File.open("test/fixtures/tapir.jpg"))
+    @other_user.update_attributes Hash.from_xml(@user.to_xml)['user']
+
+    assert_equal 'John Doe', @other_user.name,                  'Other user name should be the same'
+    assert       @other_user.avatar.file?,                      'Other user should have a file'
+    assert_equal 'kitten.jpg', @other_user.avatar_file_name,    'Other user should have correct file name'
+    assert_equal 'image/jpeg', @other_user.avatar_content_type, 'Other user should have correct content type'
+  end
+end
+
+class ActiveSupportWithURLAttachmentsTest < ActiveSupport::TestCase  
+  load_schema
+  
+  setup do
+    @user = User.create(:name => 'John Doe', :avatar_remote => File.open("test/fixtures/kitten.jpg"))
+  end
+  
+  teardown do
+    User.destroy_all
+  end
+
+  test "should create avatar_remote_url tags" do
+    assert Hash.from_xml(@user.to_xml)['user'].has_key?('avatar_remote_url')
+  end
+  
+  test "should not create avatar_remote_url tags with :include_attachments => false" do
+    assert !(Hash.from_xml(@user.to_xml(:include_attachments => false))['user'].has_key?('avatar_remote_url'))
+  end
+  
+  test "should not create avatar_remote tags" do
+    assert !(Hash.from_xml(@user.to_xml)['user'].has_key?('avatar_remote'))
+  end
+  
+  test "avatar_remote_url tags should be nil if the user is new" do
+    @new_user = User.new(:name => 'John Doe', :avatar_remote => File.open("test/fixtures/kitten.jpg"))
+    assert Hash.from_xml(@new_user.to_xml)['user']['avatar_remote_url'].nil?,    'Should have nil URL tag'
+    assert !(Hash.from_xml(@new_user.to_xml)['user'].has_key?('avatar_remote')), 'Should not have file tag'
+  end
+  
+  test "avatar_remote_url tags should be nil if the user is destroyed" do
+    @user.destroy
+    assert Hash.from_xml(@user.to_xml)['user']['avatar_remote_url'].nil?,        'Should have nil URL tag'
+    assert !(Hash.from_xml(@user.to_xml)['user'].has_key?('avatar_remote')),     'Should not have file tag'
+  end
+  
+  test "avatar_remote_url tag should point to the image's URL" do
+    assert_equal "http://localhost/users/#{@user.id}.jpg", Hash.from_xml(@user.to_xml)['user']['avatar_remote_url']
+  end
+  
+  test "avatar_remote_url tag should not raise exception when applied to another ActiveRecord" do
+    assert_nothing_raised { @new_user = User.new.from_xml(@user.to_xml) }
+  end
+  
+  test "avatar_remote_url tag should not set the file when applied to another ActiveRecord" do
+    @new_user = User.new.from_xml(@user.to_xml)
+    assert !(@new_user.avatar_remote.file?)
+  end
+  
+  test "avatar_remote_url tag should not be generated with :encode_attachments => true" do
+    assert !(Hash.from_xml(@user.to_xml(:encode_attachments => true))['user'].has_key?('avatar_remote_url'))
+  end
+  
+  test "avatar_remote file tag should be generated with :encode_attachments => true" do
+    assert Hash.from_xml(@user.to_xml(:encode_attachments => true))['user'].has_key?('avatar_remote')
+  end
+  
+  test "avatar_remote file tag should include all necessary attributes" do
+    user_xml = Hash.from_xml(@user.to_xml(:encode_attachments => true))['user']
+    assert        user_xml.has_key?('avatar_remote')
+    assert_equal  'kitten.jpg', user_xml['avatar_remote'].original_filename, 'Filename should be set'
+    assert_equal  'image/jpeg', user_xml['avatar_remote'].content_type,      'Content type should be set'
+  end
+end

data/lib/encoded_attachment/test/active_resource_test.rb

@@ -0,0 +1,276 @@
+require 'test_helper'
+require 'fileutils'
+
+class ActiveResourceBaseTest < ActiveSupport::TestCase
+  load_schema
+
+  test "should add get_attachment to ActiveResource::Connection" do
+    @connection = ActiveResource::Connection.new("http://localhost/")
+    assert @connection.methods.include?("get_attachment")
+  end
+
+  test "build user resource without exception" do
+    assert_nothing_raised { Api::User.new(:name => 'John Doe') }
+  end
+end
+
+class ActiveResourceMethodsTest < ActiveSupport::TestCase
+  setup do
+    @user = Api::User.new(:name => 'John Doe')
+  end
+  
+  test "should add attributes to schema" do
+    assert @user.known_attributes.include?("name"),                 "Should have name attribute"
+    assert @user.known_attributes.include?("avatar_file_name"),     "Should have avatar_file_name attribute"
+    assert @user.known_attributes.include?("avatar_file_size"),     "Should have avatar_file_size attribute"
+    assert @user.known_attributes.include?("avatar_content_type"),  "Should have avatar_content_type attribute"
+    assert @user.known_attributes.include?("avatar_updated_at"),    "Should have avatar_updated_at attribute"
+    assert @user.known_attributes.include?("avatar"),               "Should have avatar attribute"
+  end
+  
+  test "should wrap to_xml method" do
+    assert @user.methods.include?("to_xml_with_encoded_avatar"),    "Should have to_xml_with_encoded_avatar"
+    assert @user.methods.include?("to_xml_without_encoded_avatar"), "Should have to_xml_without_encoded_avatar"
+  end
+  
+  test "should have changed= and changed? methods" do
+    assert @user.methods.include?("avatar_changed="), "Should have avatar_changed= method"
+    assert @user.methods.include?("avatar_changed?"), "Should have avatar_changed method"
+  end
+  
+  test "should not be changed? in new record" do
+    assert !(@user.avatar_changed?)
+  end
+  
+  test "changed? should be true after attachment is set" do
+    @user.avatar = File.open("test/fixtures/kitten.jpg")
+    assert @user.avatar_changed?
+  end
+  
+  test "should have file= method" do
+    assert @user.methods.include?("avatar=")
+  end
+  
+  test "should have file_path= method" do
+    assert @user.methods.include?("avatar_path=")
+  end
+  
+  test "should have file_url= method" do
+    assert @user.methods.include?("avatar_url=")
+  end
+  
+  test "should have save_file_as method" do
+    assert @user.methods.include?("save_avatar_as")
+  end
+  
+  test "should wrap file_updated_at" do
+    @user.avatar_updated_at = "Wed May 26 01:29:08 UTC 2010"
+    assert @user.avatar_updated_at.is_a?(Time)
+  end
+end
+
+class ActiveResourceAttributesTest < ActiveSupport::TestCase
+  setup do
+    @user_record = User.create(:name => 'John Doe', :avatar => File.open("test/fixtures/tapir.jpg"))
+    @user = Api::User.new(Hash.from_xml(@user_record.to_xml)['user'])
+  end
+  
+  teardown do
+    User.destroy_all
+  end
+  
+  test "should set initial attributes" do
+    assert_equal 'tapir.jpg', @user.avatar_file_name,     'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(StringIO),            'Should set attachment to StringIO'
+    assert       !(@user.avatar_changed?),                'Should not be changed?'
+  end
+  
+  test "should set attributes if attachment is nil" do
+    @user_record = User.create(:name => 'John Doe', :avatar => nil)
+    @user = Api::User.new(Hash.from_xml(@user_record.to_xml)['user'])
+    
+    assert_nil @user.avatar_file_name,                    'Name should be nil'
+    assert_nil @user.avatar_content_type,                 'Content type should be nil'
+    assert_nil @user.avatar,                              'Attachment should be nil'
+    assert     !(@user.avatar_changed?),                  'Should not be changed?'
+  end
+  
+  test "should update attributes if initial attachment was nil" do
+    @user_record = User.create(:name => 'John Doe', :avatar => nil)
+    @user = Api::User.new(Hash.from_xml(@user_record.to_xml)['user'])
+    @user.attributes = { :avatar => File.open('test/fixtures/kitten.jpg') }
+
+    assert_equal 'kitten.jpg', @user.avatar_file_name,    'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(File),                'Should set attachment to File'
+    assert       @user.avatar_changed?,                   'Should be changed?'
+  end
+  
+  test "should be able to update attachment" do
+    @user.avatar = File.open('test/fixtures/kitten.jpg')
+    assert_equal 'kitten.jpg', @user.avatar_file_name,    'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(File),                'Should set attachment to File'
+    assert       @user.avatar_changed?,                   'Should be changed?'
+  end
+  
+  test "should be able to update attachment using attributes=" do
+    @user.attributes = { :avatar => File.open('test/fixtures/kitten.jpg') }
+    assert_equal 'kitten.jpg', @user.avatar_file_name,    'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(File),                'Should set attachment to File'
+    assert       @user.avatar_changed?,                   'Should be changed?'
+  end
+  
+  test "should be able to update attachment using path" do
+    @user.avatar_path = 'test/fixtures/kitten.jpg'
+    assert_equal 'kitten.jpg', @user.avatar_file_name,    'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(File),                'Should set attachment to File'
+    assert       @user.avatar_changed?,                   'Should be changed?'
+  end
+  
+  test "should be able to save attachment" do
+    assert_nothing_raised { @user.save_avatar_as "test/test_file.jpg" }
+    File.delete 'test/test_file.jpg' if File.exist?('test/test_file.jpg')
+  end
+  
+  test "should overwrite attachment if file exists" do
+    FileUtils.touch 'test/test_file.jpg'
+    assert_nothing_raised { @user.save_avatar_as 'test/test_file.jpg' }
+    File.delete 'test/test_file.jpg' if File.exist?('test/test_file.jpg')
+  end
+  
+  test "should not overwrite attachment if file exists and save_as is called with false" do
+    FileUtils.touch 'test/test_file.jpg'
+    assert_raises(RuntimeError) { @user.save_avatar_as 'test/test_file.jpg', false }
+    File.delete 'test/test_file.jpg' if File.exist?('test/test_file.jpg')
+  end
+end
+
+class ActiveResourceConnectionMethods < ActiveSupport::TestCase
+  def setup
+    @user_record  = User.create(:name => 'John Doe', :avatar => File.open('test/fixtures/kitten.jpg'),
+                                :avatar_remote => File.open('test/fixtures/tapir.jpg'))
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/users/#{@user_record.id}.xml", {}, @user_record.to_xml
+      mock.post   "/users.xml", {}, @user_record.to_xml, 201, "Location" => "/people/1.xml"
+      mock.put    "/users/#{@user_record.id}.xml", {}, nil, 204
+      mock.delete "/users/#{@user_record.id}.xml", {}, nil, 200
+      mock.get    "/users/#{@user_record.id}.jpg", { 'Accept' => 'image/jpeg' }, File.read('test/fixtures/tapir.jpg'),
+                  200, "Content-Type" => "image/jpeg"
+    end
+  end
+  
+  teardown do
+    User.destroy_all
+  end
+  
+  test "HTTP mock is working" do
+    @user = Api::User.find(@user_record.id)
+    assert ActiveResource::HttpMock.requests.include?(ActiveResource::Request.new(:get, "/users/#{@user_record.id}.xml")),
+           "Should receive find request"
+    assert ActiveResource::HttpMock.requests.include?(ActiveResource::Request.new(:get, "/users/#{@user_record.id}.jpg")),
+           "Should receive avatar_remote image request"
+  end
+  
+  test "should receive and parse XML, including a remote attachment" do
+    @user = Api::User.find(@user_record.id)
+    
+    assert_equal 'kitten.jpg', @user.avatar_file_name,    'Should set name'
+    assert_equal 'image/jpeg', @user.avatar_content_type, 'Should set content type'
+    assert       @user.avatar.is_a?(StringIO),            'Should set attachment to StringIO'
+    assert       !(@user.avatar_changed?),                'Should not be changed?'
+    
+    assert_equal "#{@user_record.id}.jpg", @user.avatar_remote_file_name, 'Should set remote name'
+    assert_equal 'image/jpeg', @user.avatar_remote_content_type, 'Should set remote content type'
+    assert       @user.avatar_remote.is_a?(StringIO),            'Should set remote attachment to StringIO'
+    assert       !(@user.avatar_remote_changed?),                'Remote should not be changed?'
+  end
+  
+  test "should POST a new user" do
+    @user = Api::User.new(:name => 'John Doe')
+    @user.save
+    assert ActiveResource::HttpMock.requests.include?(ActiveResource::Request.new(:post, "/users.xml"))
+  end
+  
+  test "should PUT an update" do
+    @user = Api::User.find(@user_record.id)
+    @user.name = 'Jane Doe'
+    @user.save
+    assert ActiveResource::HttpMock.requests.include?(ActiveResource::Request.new(:put, "/users/#{@user_record.id}.xml"))
+  end
+  
+  test "should DELETE when destroyed" do
+    @user = Api::User.find(@user_record.id)
+    @user.destroy
+    assert ActiveResource::HttpMock.requests.include?(ActiveResource::Request.new(:delete, "/users/#{@user_record.id}.xml")),
+           "Should have sent a DELETE request"
+  end
+end
+
+class ActiveResourceXMLGenerationTest < ActiveSupport::TestCase
+  def setup
+    @user_record = User.create(:name => 'John Doe', :avatar => File.open("test/fixtures/tapir.jpg"),
+                               :avatar_remote => File.open('test/fixtures/kitten.jpg'))
+    ActiveResource::HttpMock.respond_to do |mock|
+       mock.get    "/users/#{@user_record.id}.xml", {}, @user_record.to_xml
+       mock.post   "/users.xml", {}, @user_record.to_xml, 201, "Location" => "/people/1.xml"
+       mock.put    "/users/#{@user_record.id}.xml", {}, nil, 204
+       mock.delete "/users/#{@user_record.id}.xml", {}, nil, 200
+       mock.get    "/users/#{@user_record.id}.jpg", { 'Accept' => 'image/jpeg' }, File.read('test/fixtures/tapir.jpg'),
+                   200, "Content-Type" => "image/jpeg"
+    end
+    @user = Api::User.find(@user_record.id)
+  end
+  
+  def teardown
+    User.destroy_all
+  end
+  
+  test "should not generate XML tags because the files haven't changed" do
+    user_xml = Hash.from_xml(@user.to_xml)['user']
+    assert !(user_xml.has_key?('avatar')),         'Should not have avatar tag'
+    assert !(user_xml.has_key?('avatar_remote')),  'Should not have avatar_remote tag'
+  end
+  
+  test "should generate XML tags when the files have changed" do
+    @user.avatar_path = 'test/fixtures/kitten.jpg'
+    @user.avatar_remote = File.open("test/fixtures/tapir.jpg")
+    user_xml = Hash.from_xml(@user.to_xml)['user']
+    assert user_xml.has_key?('avatar'),         'Should have avatar tag'
+    assert user_xml.has_key?('avatar_remote'),  'Should have avatar_remote tag'
+    
+    assert user_xml['avatar'].is_a?(StringIO),  'Should be a StringIO'
+    assert_equal 'kitten.jpg', user_xml['avatar'].original_filename, 'Should have the original filename'
+  end
+  
+  test "should not generate XML tags when user is new" do
+    user_xml = Hash.from_xml(Api::User.new(:name => 'Jane Doe').to_xml)['user']
+    assert !(user_xml.has_key?('avatar')),         'Should not have avatar tag'
+    assert !(user_xml.has_key?('avatar_remote')),  'Should not have avatar_remote tag'
+  end
+  
+  test "should generate XML tags when user is new and files have been assigned" do
+    user_xml = Hash.from_xml(Api::User.new(:name => 'Jane Doe', :avatar => File.open("test/fixtures/tapir.jpg"),
+                                           :avatar_remote => File.open('test/fixtures/kitten.jpg')).to_xml)['user']
+    assert user_xml.has_key?('avatar'),         'Should have avatar tag'
+    assert user_xml.has_key?('avatar_remote'),  'Should have avatar_remote tag'
+  end
+  
+  test "should create a User from XML" do
+    @new_user = User.new.from_xml Api::User.new(:name => 'Jane Doe', :avatar => File.open("test/fixtures/tapir.jpg"),
+                                                :avatar_remote => File.open('test/fixtures/kitten.jpg')).to_xml
+    assert @new_user.save,                                       'User should save'
+    assert @new_user.avatar.file?,                               'User should have avatar file'
+    assert File.exist?(@new_user.avatar_remote.path(:original)), 'User\'s avatar remote file should exist'
+  end
+  
+  test "should update a User's files from XML" do
+    @user.avatar = File.open('test/fixtures/kitten.jpg')
+    @user_record.update_attributes Hash.from_xml(@user.to_xml)['user']
+    assert_equal  'kitten.jpg', @user_record.avatar_file_name,      'File name updated'
+    assert        File.exist?(@user_record.avatar.path(:original)), 'File saved'
+  end
+end

data/lib/encoded_attachment/test/config/database.yml

@@ -0,0 +1,19 @@
+sqlite3:
+  adapter: sqlite3
+  database: test/db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: encoded_attachment_plugin_test
+  min_messages: ERROR
+
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password: 
+  database: encoded_attachment_plugin_test

data/lib/encoded_attachment/test/config/schema.rb

@@ -0,0 +1,17 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users, :force => true do |t|
+    t.string    "name"
+    
+    t.string    "avatar_file_name"
+    t.string    "avatar_content_type"
+    t.integer   "avatar_file_size"
+    t.datetime  "avatar_updated_at"
+    
+    t.string    "avatar_remote_file_name"
+    t.string    "avatar_remote_content_type"
+    t.integer   "avatar_remote_file_size"
+    t.datetime  "avatar_remote_updated_at"
+    
+    t.timestamps
+  end
+end

data/lib/encoded_attachment/test/test_helper.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'test/unit'
+require 'logger'
+require 'bundler'
+
+Bundler.setup
+Bundler.require
+
+Paperclip.configure
+Paperclip::Railtie.insert
+
+class User < ActiveRecord::Base
+  has_attached_file        :avatar,
+                           :path => File.dirname(__FILE__) + "/avatars/:id_partition/:attachment/:style.:extension",
+                           :url =>  "/users/:id.:extension"
+  encode_attachment_in_xml :avatar
+  
+  has_attached_file        :avatar_remote,
+                           :path => File.dirname(__FILE__) + "/avatars/:id_partition/:attachment/:style.:extension",
+                           :url =>  "/users/:id.:extension"
+  encode_attachment_in_xml :avatar_remote, :send_urls => true, :root_url => "http://localhost/"
+end
+
+module Api
+  class User < ActiveResource::Base
+    self.site = "http://localhost/"
+    
+    has_encoded_attachment :avatar
+    has_encoded_attachment :avatar_remote
+    
+    schema do
+      string "name"
+    end
+  end
+end
+
+class ActiveSupport::TestCase
+  def self.load_schema
+    config = YAML::load(IO.read(File.dirname(__FILE__) + '/config/database.yml'))
+    ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/log/debug.log")
+
+    db_adapter = ENV['DB']
+
+    # no db passed, try one of these fine config-free DBs before bombing.
+    db_adapter ||=
+      begin
+        require 'rubygems'
+        require 'sqlite'
+        'sqlite'
+      rescue MissingSourceFile
+        begin
+          require 'sqlite3'
+          'sqlite3'
+        rescue MissingSourceFile
+        end
+      end
+
+    if db_adapter.nil?
+      raise "No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+    end
+  
+    ActiveRecord::Base.establish_connection(config[db_adapter])
+    load(File.dirname(__FILE__) + "/config/schema.rb")
+  end
+  
+  def self.user_with_encoded_files
+    User.encode_attachment_in_xml :avatar
+  end
+  
+  def self.user_urls
+    User.encode_attachment_in_xml :avatar, :send_urls => true, :root_url => "http://localhost/"
+  end
+end

data/lib/siterest/asset.rb

@@ -0,0 +1,27 @@
+require 'open-uri'
+require 'mime/types'
+require 'stringio'
+require 'upfile'
+require 'encoded_attachment/lib/encoded_attachment'
+
+
+module Siterest
+  class Asset < ActiveResource::Base
+    self.site = Siterest.site_resource_url
+    self.user = Siterest.token
+    
+    has_encoded_attachment :data
+
+    def url
+      "http://assets.siterest.com/#{self.path}"
+    end
+
+    def binary?
+      MIME::Types[data_content_type].first.try(:binary?)
+    end
+  
+    def to_file
+      open(url)
+    end
+  end
+end