zencoder-flix_cloud-gem 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Zencoder
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,11 @@
+FlixCloud Gem
+=============
+
+The gem for interacting with the API on [FlixCloud](http://flixcloud.com).
+
+See [http://flixcloud.com/api](http://flixcloud.com/api) for more details on the API.
+
+COPYRIGHT
+---------
+
+Copyright (c) 2009 Zencoder. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flix_cloud-gem"
+    gem.summary = %{Gem for integrating with http://flixcloud.com}
+    gem.email = "nate@sevenwire.com"
+    gem.homepage = "http://github.com/zencoder/flix_cloud-gem"
+    gem.authors = ["Nathan Sutton"]
+    gem.add_dependency('builder', '>= 2.1.2')
+    gem.add_dependency('crack', '>= 0.1.1')
+    gem.add_dependency('rest-client', '>= 0.9.2')
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flix_cloud-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/lib/flix_cloud.rb

@@ -0,0 +1,16 @@
+require 'builder'
+require 'restclient'
+require 'crack/xml'
+
+module FlixCloud; end
+
+require File.dirname(__FILE__) + '/flix_cloud/record'
+require File.dirname(__FILE__) + '/flix_cloud/job'
+require File.dirname(__FILE__) + '/flix_cloud/file_locations'
+require File.dirname(__FILE__) + '/flix_cloud/file'
+require File.dirname(__FILE__) + '/flix_cloud/input_file'
+require File.dirname(__FILE__) + '/flix_cloud/output_file'
+require File.dirname(__FILE__) + '/flix_cloud/watermark_file'
+require File.dirname(__FILE__) + '/flix_cloud/parameters'
+require File.dirname(__FILE__) + '/flix_cloud/response'
+require File.dirname(__FILE__) + '/flix_cloud/extensions/hash'

data/lib/flix_cloud/extensions/hash.rb

@@ -0,0 +1,22 @@
+module FlixCloud
+  module Extensions
+    # Both methods ripped directly out of rails
+    module Hash
+      def deep_merge(other_hash)
+        self.merge(other_hash) do |key, oldval, newval|
+          oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+          newval = newval.to_hash if newval.respond_to?(:to_hash)
+          oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
+        end
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge!(other_hash)
+        replace(deep_merge(other_hash))
+      end
+    end
+  end
+end
+
+Hash.send(:include, FlixCloud::Extensions::Hash) unless Hash.instance_methods.include?('deep_merge')

data/lib/flix_cloud/file.rb

@@ -0,0 +1,21 @@
+class FlixCloud::File < FlixCloud::Record
+
+  attr_accessor :url
+
+  record_column :parameters, 'Parameters'
+
+  def valid?
+    self.errors = []
+
+    unless url
+      self.errors << "url is required"
+    end
+
+    if parameters && !parameters.valid?
+      self.errors << {:parameters => parameters.errors}
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/file_locations.rb

@@ -0,0 +1,33 @@
+class FlixCloud::FileLocations < FlixCloud::Record
+
+  record_column :input, 'InputFile'
+  record_column :output, 'OutputFile'
+  record_column :watermark, 'WatermarkFile'
+
+  def valid?
+    self.errors = []
+
+    if input
+      unless input.valid?
+        self.errors << {:input => input.errors}
+      end
+    else
+      self.errors << "input is required"
+    end
+
+    if output
+      unless output.valid?
+        self.errors << {:output => output.errors}
+      end
+    else
+      self.errors << "output is required"
+    end
+
+    if watermark && !watermark.valid?
+      self.errors << {:watermark => watermark.errors}
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/input_file.rb

@@ -0,0 +1,2 @@
+class FlixCloud::InputFile < FlixCloud::File
+end

data/lib/flix_cloud/job.rb

@@ -0,0 +1,124 @@
+class FlixCloud::Job < FlixCloud::Record
+
+  attr_accessor :id, :initialized_at, :api_key, :recipe_id, :response
+
+  record_column :file_locations, 'FileLocations'
+
+  def initialize(attrs={})
+    super
+    self.shortcut_attributes = attrs
+  end
+
+  def valid?
+    self.errors = []
+
+    if file_locations
+      unless file_locations.valid?
+        self.errors << {:file_locations => file_locations.errors}
+      end
+    else
+      self.errors << "file_locations is required"
+    end
+
+    unless recipe_id
+      self.errors << "recipe_id is required"
+    end
+
+    unless api_key
+      self.errors << "api_key is required"
+    end
+
+    errors.empty?
+  end
+
+  def save
+    return false unless valid?
+
+    self.response = FlixCloud::Response.new(post('jobs', to_xml))
+
+    if response.success?
+      self.id = response.body_as_hash['job']['id']
+      self.initialized_at = response.body_as_hash['job']['initialized_job_at']
+    else
+      self.errors = response.errors
+    end
+
+    response.success?
+  end
+
+  def to_xml
+    xml = Builder::XmlMarkup.new
+
+    xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+
+    xml.tag!("api-request") do
+      xml.tag!("api-key", api_key)
+      xml.tag!("recipe-id", recipe_id)
+
+      if file_locations
+        xml.tag!("file-locations") do
+          if file_locations.input
+            xml.input do
+              xml.url(file_locations.input.url)
+              if file_locations.input.parameters
+                xml.parameters do
+                  xml.user(file_locations.input.parameters.user)
+                  xml.password(file_locations.input.parameters.password)
+                end
+              end
+            end
+          end
+
+          if file_locations.output
+            xml.output do
+              xml.url(file_locations.output.url)
+              if file_locations.output.parameters
+                xml.parameters do
+                  xml.user(file_locations.output.parameters.user)
+                  xml.password(file_locations.output.parameters.password)
+                end
+              end
+            end
+          end
+
+          if file_locations.watermark
+            xml.watermark do
+              xml.url(file_locations.watermark.url)
+              if file_locations.watermark.parameters
+                xml.parameters do
+                  xml.user(file_locations.watermark.parameters.user)
+                  xml.password(file_locations.watermark.parameters.password)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    xml.target!
+  end
+
+
+protected
+
+  def shortcut_attributes=(attrs)
+    translated_attributes = {}
+
+    attrs.each do |key, value|
+      if match = key.to_s.match(/^(input|output|watermark)_(url|user|password)$/)
+        file_type = match[1].to_sym
+        parameter_type = match[2].to_sym
+
+        if parameter_type == :url
+          translated_attributes.deep_merge!(:file_locations => { file_type => { :url => value}})
+        else
+          translated_attributes.deep_merge!(:file_locations => { file_type => { :parameters => { parameter_type => value}}})
+        end
+      end
+    end
+
+    self.attributes = translated_attributes unless translated_attributes.empty?
+  end
+
+end

data/lib/flix_cloud/output_file.rb

@@ -0,0 +1,2 @@
+class FlixCloud::OutputFile < FlixCloud::File
+end

data/lib/flix_cloud/parameters.rb

@@ -0,0 +1,19 @@
+class FlixCloud::Parameters < FlixCloud::File
+
+  attr_accessor :user, :password
+
+  def valid?
+    self.errors = []
+
+    unless user
+      self.errors << "user is required"
+    end
+
+    unless password
+      self.errors << "password is required"
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/record.rb

@@ -0,0 +1,38 @@
+class FlixCloud::Record
+
+  attr_accessor :errors
+
+  def initialize(attrs={})
+    self.errors = []
+    self.attributes = attrs
+  end
+
+  def attributes=(attrs)
+    attrs.each do |key, value|
+      send("#{key}=", value) if respond_to?("#{key}=")
+    end
+  end
+
+  def self.record_column(attribute, klass)
+    eval %{
+      attr_reader :#{attribute}
+
+      def #{attribute}=(value)
+        if @#{attribute}
+          @#{attribute}.attributes = value
+        else
+          @#{attribute} = FlixCloud::#{klass}.new(value)
+        end
+      end
+    }
+  end
+
+protected
+
+  def post(path, body)
+    RestClient::Resource.new(
+      "https://flixcloud.com/#{path}",
+      :verify_ssl => OpenSSL::SSL::VERIFY_PEER).post(body, :content_type => 'application/xml', :accept => 'application/xml')
+  end
+
+end

data/lib/flix_cloud/response.rb

@@ -0,0 +1,26 @@
+class FlixCloud::Response
+
+  attr_accessor :code, :body, :errors, :body_as_hash
+
+  def initialize(response)
+    self.code = response.code
+    self.body = response.to_s
+    self.body_as_hash = Crack::XML.parse(response.to_s)
+    self.errors = []
+    process_response_xml
+  end
+
+  def success?
+    errors.empty?
+  end
+
+
+protected
+
+  def process_response_xml
+    if body_as_hash['errors'] && body_as_hash['errors'].is_a?(Hash) && body_as_hash['errors']['error']
+      self.errors = Array(body_as_hash['errors']['error'])
+    end
+  end
+
+end

data/lib/flix_cloud/watermark_file.rb

@@ -0,0 +1,2 @@
+class FlixCloud::WatermarkFile < FlixCloud::File
+end

data/test/flix_cloud/file_locations_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class FlixCloud::FileLocationsTest < Test::Unit::TestCase
+
+  context "When validationg a file locations object with no attributes set" do
+    setup do
+      @file_locations = FlixCloud::FileLocations.new
+      @file_locations.valid?
+    end
+
+    should "require input" do
+      assert_match /input is required/, @file_locations.errors.to_s
+    end
+
+    should "require output" do
+      assert_match /output is required/, @file_locations.errors.to_s
+    end
+  end
+
+  context "When validating a file locations object with input, output, and watermark objects that are invalid" do
+    setup do
+      @file_locations = FlixCloud::FileLocations.new(:input => {}, :output => {}, :watermark => {})
+      @file_locations.valid?
+    end
+
+    should "inherit the input object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:input] && !error[:input].empty?
+      }, "Did not inherit input object's errors"
+    end
+
+    should "inherit the output object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:output] && !error[:output].empty?
+      }, "Did not inherit output object's errors"
+    end
+
+    should "inherit the watermark object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:watermark] && !error[:watermark].empty?
+      }, "Did not inherit watermark object's errors"
+    end
+  end
+
+end

data/test/flix_cloud/file_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class FlixCloud::FileTest < Test::Unit::TestCase
+
+  context "When validating a file object with no attributes set" do
+    setup do
+      @file = FlixCloud::File.new
+      @file.valid?
+    end
+
+    should "require url" do
+      assert_match /url is required/, @file.errors.to_s
+    end
+  end
+
+  context "When validating a file object with a parameters object that is invalid" do
+    setup do
+      @file = FlixCloud::File.new(:parameters => {})
+      @file.valid?
+    end
+
+    should "inherit the parameters object's errors" do
+      assert @file.errors.any?{|error|
+        error.is_a?(Hash) && error[:parameters] && !error[:parameters].empty?
+      }, "Did not inherit parameters object's errors"
+    end
+  end
+
+end

data/test/flix_cloud/input_file_test.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+
+class FlixCloud::InputFileTest < Test::Unit::TestCase
+  should "do something unique, eventually" do
+  end
+end

data/test/flix_cloud/job_test.rb

@@ -0,0 +1,257 @@
+require 'test_helper'
+
+class FlixCloud::JobTest < Test::Unit::TestCase
+
+  context "When validating a job object with no attributes set" do
+    setup do
+      @job = FlixCloud::Job.new
+      @job.valid?
+    end
+
+    should "require an api key" do
+      assert_match /api_key is required/, @job.errors.to_s
+    end
+
+    should "require file_locations" do
+      assert_match /file_locations is required/, @job.errors.to_s
+    end
+
+    should "require recipe_id" do
+      assert_match /recipe_id is required/, @job.errors.to_s
+    end
+  end
+
+
+  context "When validating a job object with a file_locations object that is invalid" do
+    setup do
+      @job = FlixCloud::Job.new(:file_locations => {})
+      @job.valid?
+    end
+
+    should "inherit the file_locations object's errors" do
+      assert @job.errors.any?{|error|
+        error.is_a?(Hash) && error[:file_locations] && !error[:file_locations].empty?
+      }, "Did not inherit file_locations object's errors"
+    end
+  end
+
+
+  context "When validating a job object with errors on the deepest nested object possible (parameters)" do
+    setup do
+      @job = FlixCloud::Job.new(:file_locations => {:input => {:parameters => {}}})
+      @job.valid?
+    end
+
+    should "inherit the errors of the deepest nested object possible (parameters)" do
+      first_level_errors = @job.errors.find{|error| error.is_a?(Hash) && error[:file_locations] && !error[:file_locations].empty? }[:file_locations]
+      second_level_errors = first_level_errors.find{|error| error.is_a?(Hash) && error[:input] && !error[:input].empty? }[:input]
+
+      assert second_level_errors.any?{|error|
+        error.is_a?(Hash) && error[:parameters] && !error[:parameters].empty?
+      }, "Did not inherit the errors of the deepest nested object possible (parameters)"
+    end
+  end
+
+
+  context "A job with no attributes set" do
+    setup do
+      @job = FlixCloud::Job.new
+    end
+
+    should "serialize to xml, excluding everything but api-key and recipe-id" do
+      assert_equal %{<?xml version="1.0" encoding="UTF-8"?><api-request><api-key></api-key><recipe-id></recipe-id></api-request>}, @job.to_xml
+    end
+  end
+
+
+  context "A job with file_locations set" do
+    setup do
+      @job = FlixCloud::Job.new(:file_locations => {})
+    end
+
+    should "serialize to xml, excluding everything but api-key, recipe-id, and file-locations" do
+      assert_equal %{<?xml version="1.0" encoding="UTF-8"?><api-request><api-key></api-key><recipe-id></recipe-id><file-locations></file-locations></api-request>}, @job.to_xml
+    end
+  end
+
+
+  context "A job with file_locations and input set" do
+    setup do
+      @job = FlixCloud::Job.new(:file_locations => {:input => {}})
+    end
+
+    should "serialize to xml, excluding everything but api-key, recipe-id, file-locations, and input" do
+      assert_equal %{<?xml version="1.0" encoding="UTF-8"?><api-request><api-key></api-key><recipe-id></recipe-id><file-locations><input><url></url></input></file-locations></api-request>}, @job.to_xml
+    end
+  end
+
+
+  context "A job with file-locations, input, and input-parameters set" do
+    setup do
+      @job = FlixCloud::Job.new(:file_locations => {:input => {:parameters => {}}})
+    end
+
+    should "serialize to xml, excluding everything but api-key, recipe-id, file-locations, input, and input-parameters" do
+      assert_equal %{<?xml version="1.0" encoding="UTF-8"?><api-request><api-key></api-key><recipe-id></recipe-id><file-locations><input><url></url><parameters><user></user><password></password></parameters></input></file-locations></api-request>}, @job.to_xml
+    end
+  end
+
+
+  context "A job with all attributes set" do
+    setup do
+      @job = FlixCloud::Job.new(:recipe_id => 1,
+                                :api_key => 'this_is_an_api_key',
+                                :file_locations => { :input => { :url => 'http://flixcloud.com/somefile.mp4',
+                                                                 :parameters => { :user => 'user',
+                                                                                  :password => 'password'}},
+                                                     :output => { :url => 'ftp://flixcloud.com/somefile.mp4',
+                                                                  :parameters => { :user => 'user',
+                                                                                   :password => 'password'}},
+                                                     :watermark => { :url => 'http://flixcloud.com/somefile.mp4',
+                                                                     :parameters => { :user => 'user',
+                                                                                      :password => 'password'}}})
+    end
+
+    should "serialize everything to xml" do
+      assert_equal %{<?xml version="1.0" encoding="UTF-8"?><api-request><api-key>this_is_an_api_key</api-key><recipe-id>1</recipe-id><file-locations><input><url>http://flixcloud.com/somefile.mp4</url><parameters><user>user</user><password>password</password></parameters></input><output><url>ftp://flixcloud.com/somefile.mp4</url><parameters><user>user</user><password>password</password></parameters></output><watermark><url>http://flixcloud.com/somefile.mp4</url><parameters><user>user</user><password>password</password></parameters></watermark></file-locations></api-request>}, @job.to_xml
+    end
+  end
+
+
+  context "An invalid job when attempting to save" do
+    setup do
+      @job = FlixCloud::Job.new
+      @result = @job.save
+    end
+
+    should "return false" do
+      assert_equal false, @result
+    end
+
+    should "set errors on the job" do
+      assert @job.errors.is_a?(Array)
+      assert_not_equal [], @job.errors
+    end
+  end
+
+  context "A valid job when attempting to save" do
+    setup do
+      FakeWeb.allow_net_connect = false
+      @job = FlixCloud::Job.new(:recipe_id => 1,
+                                :api_key => 'this_is_an_api_key',
+                                :file_locations => { :input => { :url => 'http://flixcloud.com/somefile.mp4',
+                                                                 :parameters => { :user => 'user',
+                                                                                  :password => 'password'}},
+                                                     :output => { :url => 'ftp://flixcloud.com/somefile.mp4',
+                                                                  :parameters => { :user => 'user',
+                                                                                   :password => 'password'}},
+                                                     :watermark => { :url => 'http://flixcloud.com/somefile.mp4',
+                                                                     :parameters => { :user => 'user',
+                                                                                      :password => 'password'}}})
+    end
+
+    teardown do
+      FakeWeb.clean_registry
+      FakeWeb.allow_net_connect = true
+    end
+
+    context "when saving with malformed xml (should really never happen, but what if?)" do
+      setup do
+        FakeWeb.register_uri(:post, 'https://flixcloud.com/jobs', :string => %{<?xml version="1.0" encoding="UTF-8"?><errors><error>Malformed XML received, please check the syntax of your XML</error></errors>},
+                                                                  :status => ['400', 'Bad Request'])
+      end
+
+      should "raise a RequestFailed error" do
+        assert_raises RestClient::RequestFailed do
+          @job.save
+        end
+      end
+    end
+
+
+    context "when saving and the schema doesn't validate (should really never happen, but what if?)" do
+      setup do
+        FakeWeb.register_uri(:post, 'https://flixcloud.com/jobs', :string => %{<?xml version="1.0" encoding="UTF-8"?><errors><error>You are missing this thing and that thing</error></errors>},
+                                                                  :status => ['400', 'Bad Request'])
+      end
+
+      should "raise a RequestFailed error" do
+        assert_raises RestClient::RequestFailed do
+          @job.save
+        end
+      end
+    end
+
+
+    context "when saving and there are errors on the job so it can't be saved" do
+      setup do
+        FakeWeb.register_uri(:post, 'https://flixcloud.com/jobs', :string => %{<?xml version="1.0" encoding="UTF-8"?><errors><error>You are missing this thing and that thing</error></errors>},
+                                                                  :status => ['200', 'OK'])
+      end
+
+      should "return false" do
+        assert_equal false, @job.save
+      end
+
+      should "set the jobs errors to the response body's errors" do
+        @job.save
+        assert_equal ["You are missing this thing and that thing"], @job.errors
+      end
+    end
+
+    context "when saving was successful" do
+      setup do
+        FakeWeb.register_uri(:post, 'https://flixcloud.com/jobs', :string => %{<?xml version="1.0" encoding="UTF-8"?><job><id type="integer">1</id><initialized-job-at type="datetime">2009-04-07T23:15:33+02:00</initialized-job-at></job>},
+                                                                  :status => ['200', 'OK'])
+      end
+
+      should "return true" do
+        assert_equal true, @job.save
+      end
+
+      should "save the id from the response on the job" do
+        @job.save
+        assert_equal 1, @job.id
+      end
+
+      should "save the initialization time from the response on the job" do
+        @job.save
+        assert_equal "Tue Apr 07 21:15:33 UTC 2009", @job.initialized_at.to_s
+      end
+    end
+  end
+
+  context "When using shortcut attributes for job initialization" do
+    setup do
+      @job = FlixCloud::Job.new(:api_key => 'your-api-key',
+                                :recipe_id => 2,
+                                :input_url          => 'your-input-url',
+                                :input_user         => 'your-input-user',
+                                :input_password     => 'your-input-password',
+                                :output_url         => 'your-output-url',
+                                :output_user        => 'your-output-user',
+                                :output_password    => 'your-output-password',
+                                :watermark_url      => 'your-watermark-url',
+                                :watermark_user     => 'your-watermark-user',
+                                :watermark_password => 'your-watermark-password')
+    end
+
+    should "set the urls" do
+      assert_equal 'your-input-url', @job.file_locations.input.url
+      assert_equal 'your-output-url', @job.file_locations.output.url
+      assert_equal 'your-watermark-url', @job.file_locations.watermark.url
+    end
+
+    should "set the users" do
+      assert_equal 'your-input-user', @job.file_locations.input.parameters.user
+      assert_equal 'your-output-user', @job.file_locations.output.parameters.user
+      assert_equal 'your-watermark-user', @job.file_locations.watermark.parameters.user
+    end
+
+    should "set the passwords" do
+      assert_equal 'your-input-password', @job.file_locations.input.parameters.password
+      assert_equal 'your-output-password', @job.file_locations.output.parameters.password
+      assert_equal 'your-watermark-password', @job.file_locations.watermark.parameters.password
+    end
+  end
+end

data/test/flix_cloud/output_files_test.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+
+class FlixCloud::OutputFileTest < Test::Unit::TestCase
+  should "do something unique, eventually" do
+  end
+end

data/test/flix_cloud/parameters_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class FlixCloud::ParametersTest < Test::Unit::TestCase
+
+  context "When validating a parameters object with no attributes set" do
+    setup do
+      @parameters = FlixCloud::Parameters.new
+      @parameters.valid?
+    end
+
+    should "require user" do
+      assert_match /user is required/, @parameters.errors.to_s
+    end
+
+    should "require password" do
+      assert_match /password is required/, @parameters.errors.to_s
+    end
+  end
+
+end

data/test/flix_cloud/record_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class FlixCloud::BogusRecordTestClass < FlixCloud::Record
+  record_column :bogus_record_test_child, 'BogusRecordTestChildClass'
+end
+
+class FlixCloud::BogusRecordTestChildClass < FlixCloud::Record
+  attr_accessor :bogus_attribute
+end
+
+class FlixCloud::RecordTest < Test::Unit::TestCase
+
+  context "With a record object initialized with no options" do
+    setup do
+      @record = FlixCloud::Record.new
+    end
+
+    should "intialize errors to an empty array" do
+      assert_equal [], @record.errors
+    end
+  end
+
+  context "With a record object initialized with options" do
+    setup do
+      @record = FlixCloud::Record.new(:errors => 'will be set, but', :bad_attributes => 'will not be set')
+    end
+
+    should "set the values of attributes that have attr_writers" do
+      assert_equal 'will be set, but', @record.errors
+    end
+  end
+
+  context "With a bogus class has a record column and has been initialized with attributes" do
+    setup do
+      @bogus_record = FlixCloud::BogusRecordTestClass.new(:bogus_record_test_child => {:bogus_attribute => 'bogus value'})
+    end
+
+    should "initialize both the parent class and the child class appropriately, assigning to the child attributes" do
+      assert_not_nil @bogus_record
+      assert @bogus_record.bogus_record_test_child.is_a?(FlixCloud::BogusRecordTestChildClass)
+      assert_equal 'bogus value', @bogus_record.bogus_record_test_child.bogus_attribute
+    end
+
+    should "update the child attributes when assigning to the parent's child object attribute (confusing?)" do
+      @bogus_record.bogus_record_test_child = {:bogus_attribute => 'a new bogus value'}
+      assert_equal 'a new bogus value', @bogus_record.bogus_record_test_child.bogus_attribute
+    end
+  end
+
+end

data/test/flix_cloud/response_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+class FlixCloud::ResponseTest < Test::Unit::TestCase
+
+  context "A response initialized with a rest client response" do
+    setup do
+      @rest_client_response = stub_rest_client_response(200, '<?xml version="1.0" encoding="UTF-8"?><something>wonderful</something>')
+      @response = FlixCloud::Response.new(@rest_client_response)
+    end
+
+    should "store code in the code attribute" do
+      assert_equal @rest_client_response.code, @response.code
+    end
+
+    should "store the body of the message in the body attribute" do
+      assert_equal @rest_client_response.to_s, @response.body
+    end
+
+    should "store body converted to a hash in the body_as_hash attribute" do
+      assert_equal Crack::XML.parse(@rest_client_response.to_s), @response.body_as_hash
+    end
+
+    should "initialize errors to an empty array" do
+      assert_equal [], @response.errors
+    end
+  end
+
+  context "A response initialized with a rest client response with a blank message body" do
+    setup do
+      @response = FlixCloud::Response.new(stub_rest_client_response(200, ''))
+    end
+
+    should "be successful" do
+      assert @response.success?
+    end
+
+    should "have a blank array for the errors attribute" do
+      assert_equal [], @response.errors
+    end
+  end
+
+  context "A response initialized with a rest client response with a message body of errors" do
+    setup do
+      @response = FlixCloud::Response.new(stub_rest_client_response(200, '<?xml version="1.0" encoding="UTF-8"?><errors><error>There was an error doing something</error></errors>'))
+    end
+
+    should "not be successful" do
+      assert !@response.success?
+    end
+
+    should "store the errors in the errors attribute" do
+      assert_equal ['There was an error doing something'], @response.errors
+    end
+  end
+
+end

data/test/flix_cloud/watermark_file_test.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+
+class FlixCloud::WatermarkFileTest < Test::Unit::TestCase
+  should "do something unique, eventually" do
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'fakeweb'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'flix_cloud'
+
+class Test::Unit::TestCase
+  def stub_rest_client_response(code, body)
+    stub(:code => code, :to_s => body)
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: zencoder-flix_cloud-gem
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Nathan Sutton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: crack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+    version: 
+description: 
+email: nate@sevenwire.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/flix_cloud.rb
+- lib/flix_cloud/extensions/hash.rb
+- lib/flix_cloud/file.rb
+- lib/flix_cloud/file_locations.rb
+- lib/flix_cloud/input_file.rb
+- lib/flix_cloud/job.rb
+- lib/flix_cloud/output_file.rb
+- lib/flix_cloud/parameters.rb
+- lib/flix_cloud/record.rb
+- lib/flix_cloud/response.rb
+- lib/flix_cloud/watermark_file.rb
+- test/flix_cloud/file_locations_test.rb
+- test/flix_cloud/file_test.rb
+- test/flix_cloud/input_file_test.rb
+- test/flix_cloud/job_test.rb
+- test/flix_cloud/output_files_test.rb
+- test/flix_cloud/parameters_test.rb
+- test/flix_cloud/record_test.rb
+- test/flix_cloud/response_test.rb
+- test/flix_cloud/watermark_file_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/zencoder/flix_cloud-gem
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Gem for integrating with http://flixcloud.com
+test_files: 
+- test/flix_cloud/file_locations_test.rb
+- test/flix_cloud/file_test.rb
+- test/flix_cloud/input_file_test.rb
+- test/flix_cloud/job_test.rb
+- test/flix_cloud/output_files_test.rb
+- test/flix_cloud/parameters_test.rb
+- test/flix_cloud/record_test.rb
+- test/flix_cloud/response_test.rb
+- test/flix_cloud/watermark_file_test.rb
+- test/test_helper.rb