right_publish 0.2.0

data/spec/repos/yum_spec.rb

@@ -0,0 +1,282 @@
+require 'right_publish/repo'
+require 'spec_helper'
+
+describe RightPublish::YumRepo do
+
+  def pkg_parts(path)
+    result = {:name=>nil, :version=>nil, :arch=>nil}
+    if /([A-Za-z\-+]+)-([0-9][A-Za-z0-9\-\.]*)\.(#{RightPublish::YumRepo::PKG_TYPES.join('|')})\.rpm\Z/.match(path)
+      result[:name] = $1
+      result[:version] = $2
+      result[:arch] = $3
+    end
+    result
+  end
+
+
+  before(:each) do
+    @repo_subdir = 'fake/'
+    @repo = flexmock(RightPublish::RepoManager.get_repository(:yum_repo)) do |obj|
+      obj.should_receive(:fetch)
+      obj.should_receive(:store)
+      obj.should_receive(:do_in_subdir).and_return {|dir,block| block.call}
+      obj.should_receive(:yum_prune)
+      obj.should_receive(:pkg_parts).and_return { |pkg| pkg_parts(pkg) }
+    end
+
+    flexmock(RightPublish::Profile) do |obj|
+      obj.should_receive(:log).and_return { |str,dbg| }
+    end
+
+    flexmock(File) { |obj| obj.should_receive(:file?).and_return(true) }
+  end
+
+  [false, true].each do |should_sign|
+    context "#publish#{" and sign" if should_sign}" do
+
+      # Test the EPEL (not flat) repo profile type
+      context "EPEL layout" do
+
+        def build_expectations(pkgs, expected_dists)
+          pkgs = Array(pkgs)
+
+          pkgs.each do |pkg|
+            pkg_arch = pkg_parts(pkg)[:arch]
+            dest_archs = case pkg_arch
+                         when RightPublish::YumRepo::SRC_ALL_ARCH
+                           [RightPublish::YumRepo::SRC_ALL_PATH]
+                         when RightPublish::YumRepo::BIN_ALL_ARCH
+                           RightPublish::YumRepo::ARCHITECTURES
+                         else
+                           [pkg_arch]
+                         end
+
+            expected_dists.each_pair do |dist,releases|
+              releases.each do |release|
+                dest_archs.each do |arch|
+                  dist_path = File.join(@repo_subdir, @epel_version.to_s, dist.to_s, release, arch)
+                  @install_expectations[dist_path] ||= []
+                  @install_expectations[dist_path] << pkg
+                end
+              end
+            end
+          end
+          @repo.should_receive(:install_file).and_return do |pkg,dir|
+            @install_expectations.should be_has_key(dir)
+            @install_expectations[dir].delete(pkg)
+            @install_expectations.delete(dir) if @install_expectations[dir].empty?
+          end
+          system_calls = @install_expectations.size
+          system_sign_calls = (@profile.config[:yum_repo][:gpg_key_id]) ? 1 : 0
+          @repo.should_receive(:system).times(system_calls).and_return(0)
+          @repo.should_receive(:shellout_with_password).times(system_sign_calls).and_return(0)
+        end
+
+        before(:each) do
+          @epel_dists = {:el=>['5','6'],:fc=>['12','13']}
+          @epel_version = 1
+          @install_expectations = {}
+          @profile = flexmock(RightPublish::Profile) do |obj|
+            obj.should_receive(:config).and_return {
+              { :verbose=>false,
+                :remote_storage=>{:provider=>'mockremote'},
+                :local_storage=>{:provider=>'mocklocal'},
+                :yum_repo=>{
+                  :epel=>@epel_version,
+                  :subdir=>@repo_subdir,
+                  :dists=>@epel_dists,
+                  :gpg_key_id=>should_sign,
+                  :gpg_password=>'fakepass'}
+              }
+            }
+          end
+        end
+
+        after(:each) do
+          @install_expectations.should be_empty
+        end
+
+        # Test for publish noarch packages (multicasting)
+        context "NoArch Packages" do
+          it "installs a single noarch rpm file to all distribution/architectures" do
+            rpm_file = 'foo-1.noarch.rpm'
+            build_expectations(rpm_file,@epel_dists)
+            @repo.publish(rpm_file, nil)
+          end
+
+          it "installs a single src rpm file to all dists" do
+            rpm_file = 'foo-1.src.rpm'
+            build_expectations(rpm_file,@epel_dists)
+            @repo.publish(rpm_file, nil)
+          end
+
+          it "installs a list of noarch rpm files to all distribution/architectures" do
+            rpm_files = ['foo-1.noarch.rpm', 'bar-2.noarch.rpm']
+            build_expectations(rpm_files,@epel_dists)
+            @repo.publish(rpm_files, nil)
+          end
+
+          it "globs and installs a directory of noarch rpm files to all distributions/architectures" do
+            rpm_files = ['foo-1.noarch.rpm', 'bar-2.src.rpm']
+            build_expectations(rpm_files,@epel_dists)
+            flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+            flexmock(Dir) { |obj| obj.should_receive(:glob).and_return(rpm_files) }
+            @repo.publish('somedir/', nil)
+          end
+
+          it "fails with no files in a dir" do
+            flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+            flexmock(Dir) { |obj| obj.should_receive(:glob).and_return([]) }
+            @repo.should_receive(:system).never
+            expect { @repo.publish('some_dir/', nil) }.to raise_error(RuntimeError)
+          end
+
+          it "fails with files missing a rpm extenstion" do
+            rpm_files = ['foo-1.noarch.rpm', 'bar-2.noarch.deb']
+            @repo.should_receive(:system).never
+            expect { @repo.publish(rpm_files, nil) }.to raise_error(RuntimeError)
+          end
+
+          it "fails with a mix of noarch and binary rpms" do
+            rpm_files = ['foo-1.noarch.rpm', 'bar-2.x86_64.rpm']
+            @repo.should_receive(:system).never
+            expect { @repo.publish(rpm_files, nil) }.to raise_error(RuntimeError)
+          end
+        end # end NoArch context
+
+        context "Architecture Dependant Packages" do
+          before(:each) do
+            @target_distribution_map = {:fc=>['12']}
+            @target_distribution_str = 'fc/12'
+          end
+
+          it "installs a single x86_64 rpm file to a dist" do
+            rpm_file = 'foo-1.x86_64.rpm'
+            build_expectations(rpm_file,@target_distribution_map)
+            @repo.publish(rpm_file, @target_distribution_str)
+          end
+
+          it "installs a list of x86_64 rpms to a dist" do
+            rpm_files = ['foo-1.x86_64.rpm', 'bar-2.x86_64.rpm']
+            build_expectations(rpm_files,@target_distribution_map)
+            @repo.publish(rpm_files, @target_distribution_str)
+          end
+
+          it "installs a directory mixed of x86_64 and i386 rpms to a dist" do
+            rpm_files = ['foo-1.x86_64.rpm', 'bar-2.i386.rpm']
+            build_expectations(rpm_files,@target_distribution_map)
+            flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+            flexmock(Dir) { |obj| obj.should_receive(:glob).and_return(rpm_files) }
+            @repo.publish('some_dir/', @target_distribution_str)
+          end
+
+          it "fails with no files in a dir" do
+            flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+            flexmock(Dir) { |obj| obj.should_receive(:glob).and_return([]) }
+            @repo.should_receive(:system).never
+            expect { @repo.publish('some_dir/', @target_distribution_str) }.to raise_error(RuntimeError)
+          end
+
+          it "fails with files missing a rpm extension" do
+            rpm_files = ['foo-1.x86_64.rpm', 'bar-2.i386.deb']
+            @repo.should_receive(:system).never
+            expect { @repo.publish(rpm_files, @target_distribution_str) }.to raise_error(RuntimeError)
+          end
+
+          it "fails with unknown architectures" do
+            rpm_files = ['foo-1.ppc.rpm', 'bar-2.ppc.rpm']
+            @repo.should_receive(:system).never
+            expect { @repo.publish(rpm_files, @target_distribution_str) }.to raise_error(RuntimeError)
+          end
+
+          it "fails when not provided with a target" do
+            rpm_files = ['foo-1.x86_64.rpm', 'bar-2.i386.rpm']
+            @repo.should_receive(:system).never
+            expect { @repo.publish(rpm_files, nil) }.to raise_error(RuntimeError)
+          end
+        end # end Architecture Dependant context
+      end # end EPEL context
+
+      # Test the Flat repo profile type
+      context "Flat layout" do
+        def build_expectations(pkgs)
+          @install_expectations = Array(pkgs)
+          @repo.should_receive(:install_file).and_return do |pkg,dir|
+            @install_expectations.delete(pkg)
+          end
+          system_calls = 1
+          system_sign_calls = (@profile.config[:yum_repo][:gpg_key_id]) ?  1 : 0
+          @repo.should_receive(:system).times(system_calls).and_return(0)
+          @repo.should_receive(:shellout_with_password).times(system_sign_calls).and_return(0)
+        end
+
+        before(:each) do
+          @epel_version = false
+          @install_expectations = []
+          @profile = flexmock(RightPublish::Profile) do |obj|
+            obj.should_receive(:config).and_return {
+              { :verbose=>false,
+                :remote_storage=>{:provider=>'mockremote'},
+                :local_storage=>{:provider=>'mocklocal'},
+                :yum_repo=>{
+                  :epel=>@epel_version,
+                  :subdir=>@repo_subdir,
+                  :gpg_key_id=>should_sign,
+                  :gpg_password=>'fakepass'}
+              }
+            }
+          end
+        end
+
+        after(:each) do
+          @install_expectations.should be_empty
+        end
+
+        it "installs a single rpm file to repo" do
+          rpm_file = 'foo-1.noarch.rpm'
+          build_expectations(rpm_file)
+          @repo.publish(rpm_file, nil)
+        end
+
+        it "installs a single src rpm file to repo" do
+          rpm_file = 'foo-1.src.rpm'
+          build_expectations(rpm_file)
+          @repo.publish(rpm_file, nil)
+        end
+
+        it "installs a list of rpm files to repo" do
+          rpm_files = ['foo-1.x86_64.rpm', 'bar-2.x86_64.rpm']
+          build_expectations(rpm_files)
+          @repo.publish(rpm_files, nil)
+        end
+
+        it "globs and installs a directory of rpm files to repo" do
+          rpm_files = ['foo-1.noarch.rpm', 'bar-2.src.rpm']
+          build_expectations(rpm_files)
+          flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+          flexmock(Dir) { |obj| obj.should_receive(:glob).and_return(rpm_files) }
+          @repo.publish('somedir/', nil)
+        end
+
+        it "succeeds with a mix of noarch and binary rpms" do
+          rpm_files = ['foo-1.noarch.rpm', 'bar-2.x86_64.rpm']
+          build_expectations(rpm_files)
+          @repo.publish(rpm_files, nil)
+        end
+
+        it "fails with no files in a dir" do
+          flexmock(File) { |obj| obj.should_receive(:directory?).and_return(true) }
+          flexmock(Dir) { |obj| obj.should_receive(:glob).and_return([]) }
+          @repo.should_receive(:system).never
+          expect { @repo.publish('some_dir/', nil) }.to raise_error(RuntimeError)
+        end
+
+        it "fails with files missing a rpm extenstion" do
+          rpm_files = ['foo-1.i386.rpm', 'bar-2.noarch.deb']
+          @repo.should_receive(:system).never
+          expect { @repo.publish('some_dir/', nil) }.to raise_error(RuntimeError)
+        end
+      end # end Flat context
+    end # end #publish context
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2012- RightScale Inc
+#
+# 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.
+
+require 'rubygems'
+require 'bundler/setup'
+require 'flexmock'
+require 'ruby-debug'
+require 'simplecov' unless RUBY_VERSION =~ /1\.8/
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end

data/spec/storage_manager_spec.rb

@@ -0,0 +1,71 @@
+require 'right_publish/storage'
+require 'spec_helper'
+
+describe RightPublish::StorageManager do
+
+  def is_registered?(name, key)
+    @storage_types = RightPublish::StorageManager.storage_types
+    @storage_types.should have_key(name)
+    @storage_types[name].should equal(key)
+    RightPublish::StorageManager.get_storage(key)::STORAGE_KEY.should be_equal(key)
+  end
+
+  it "should provide a hash of known storage types" do
+    RightPublish::StorageManager.storage_types.should be_instance_of(Hash)
+  end
+
+  it "returns nil for unknown storage types" do
+    RightPublish::StorageManager.get_storage(:doesnotexist_storage).should be_equal(nil)
+  end
+
+  it "should know about the local storage" do
+    is_registered?('local', :local_storage)
+  end
+
+  it "should know about the s3 storage" do
+    is_registered?('s3', :s3_storage)
+  end
+
+  context ".register_storage" do
+    it "rejects storage without a STORAGE_KEY" do
+      class MissingKey
+      end
+      expect { RightPublish::StorageManager.register_storage(MissingKey) }.to raise_error(NameError)
+    end
+
+    it "rejects storage whose key does not end in _storage" do
+      class BadKey
+        STORAGE_KEY = :bad_key
+      end
+      expect { RightPublish::StorageManager.register_storage(BadKey) }.to raise_error(TypeError)
+    end
+
+    it "rejects storage who do not provide .get_directories" do
+      class NoDirectories
+        STORAGE_KEY = :nooptions_storage
+      end
+      expect { RightPublish::StorageManager.register_storage(NoDirectories) }.to raise_error(TypeError)
+    end
+
+    it "rejects storage who do not provide options" do
+      class NoOptions
+        STORAGE_KEY = :nooptions_storage
+        def self.get_directories()
+        end
+      end
+      expect { RightPublish::StorageManager.register_storage(NoOptions) }.to raise_error(NameError)
+    end
+
+    it "accpets storage who are properly defined" do
+      class GoodStorage
+        STORAGE_KEY = :good_storage
+        STORAGE_OPTIONS = {}
+        def self.get_directories()
+        end
+      end
+      RightPublish::StorageManager.register_storage(GoodStorage).should be_equal(nil)
+      is_registered?('good', :good_storage)
+    end
+  end
+
+end

data/spec/storage_spec.rb

@@ -0,0 +1,317 @@
+require 'right_publish/storage'
+require 'spec_helper'
+
+describe RightPublish::Storage do
+
+  # Create a File entity.
+  def make_file(name, expects, copy, destroy)
+    file = flexmock("File:#{name}")
+
+    # We can set some expectations on it like if we believe we're
+    # going to be removed from Storage.
+    destroy_calls = 0
+    munge_body = false
+    if expects.instance_of? Hash
+      destroy_calls = (expects.has_key?(:destroy) && expects[:destroy] && 1) || 0
+      munge_body = (expects.has_key?(:munge_body) && expects[:munge_body]) || false
+    end
+
+    # For simplicity use the filename as the "contents" but provide a
+    # way to corrupt it to force testing content, not name matching.
+    file.should_receive(:body).and_return { (munge_body && 'data_mismatch') || name }
+
+    # Use the copy callback to insert a copy of ourselves at a different
+    # path (Remote duplication).
+    file.should_receive(:copy).and_return do |dir_key,dest|
+      new_file = make_file(dest, nil, copy, destroy)
+      copy.call(new_file)
+    end
+
+    # Use the destroy callback to remove outselves from the Files obj.
+    file.should_receive(:destroy).times(destroy_calls).and_return { destroy.call(name) }
+    file.should_receive(:key).and_return(name)
+    file
+  end
+
+  # Create a Fog Storage Mock
+  def make_storage(path, file_hash, expectations)
+    # List of File mocks bound to this storage instance
+    files = []
+
+    # These procedures are used as callbacks for the File mocks to copy
+    # or destroy themselves and have a side-effect on the about Array
+    create_proc = Proc.new { |file| files << file }
+    delete_proc = Proc.new { |file| files.delete_if { |f| f.key == file } }
+
+    # Create the File mocks and store in the Array
+    file_hash.each_pair do |name,expects|
+      files << make_file(name, expects, create_proc, delete_proc )
+    end
+
+    # Fog has a weird notion of a 'Files' and 'Directory' object being
+    # distinct. We care here because create is called on the 'Files'
+    # rather then on the 'Directory' and it is Enumerable.
+    file_list = flexmock(files)
+    file_list.should_receive(:create).
+      times(expectations[:create_call]).
+      and_return do |args|
+        new_file = make_file( args[:key], nil, create_proc, delete_proc )
+        files << new_file
+        new_file
+      end
+
+    # The only thing ever called on the Storage object is the
+    # #get_directories interface, or at least that's all we use.
+    obj = flexmock('Storage')
+    obj.should_receive(:get_directories).and_return do
+      # The Directory object is synonymous to an S3 bucket object
+      # and is responsible for providing the Files enumerable and
+      # calculating the MD5 hash of a given file.
+      f = flexmock('Directory')
+      f.should_receive(:compute_md5).and_return {|file| Digest::MD5.hexdigest(File.basename(file.body))}
+      f.should_receive(:files).and_return(file_list)
+      f.should_receive(:key).and_return(path)
+      f
+    end
+    obj
+  end
+
+  # In order to match we just make sure that the sizes of the Files
+  # objects match and that every File within A is also within B. We don't
+  # have to check the reverse since the sizes implies it.
+  def storage_match?(a,b)
+    a_files = a.get_directories.files
+    b_files = b.get_directories.files
+
+    return false if a_files.count != b_files.count
+    a_files.all? { |a_f|
+      name = a_f.key
+      b_files.any? { |b_f| name == b_f.key }
+    }
+  end
+
+  before(:each) do
+    flexmock(RightPublish::Profile) do |obj|
+      obj.should_receive(:log).and_return { |str,debug|
+      }
+    end
+  end
+
+  context ".sync_dirs" do
+    it "handles source AND destination storages that are empty" do
+      src_storage = make_storage(
+        'foo',
+        {},
+        {:create_call=>0} )
+
+      # First copy of file1 will use create, second will be duped
+      dest_storage = make_storage(
+        'bar',
+        {},
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "does nothing with identical directories" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil },
+        {:create_call=>0} )
+
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil },
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "copies a new file to the destination" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil,
+          'file4'=>nil },
+        {:create_call=>0} )
+
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil },
+        {:create_call=>1} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "handles source storages that are empty" do
+      src_storage = make_storage(
+        'foo',
+        {},
+        {:create_call=>0} )
+
+      # First copy of file1 will use create, second will be duped
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>{:destroy=>true} },
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "handles destination storages that are empty" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil },
+        {:create_call=>0} )
+
+      # First copy of file1 will use create, second will be duped
+      dest_storage = make_storage(
+        'bar',
+        {},
+        {:create_call=>1} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "leaves an extraneous file in the destination w/o :sweep" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil },
+        {:create_call=>0} )
+
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil,
+          'file4'=>nil },
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage)
+
+      # We should NOT match here. Not sure what the usecase of this
+      # is, but it's tested anyways.
+      storage_match?(src_storage, dest_storage).should be_false
+    end
+
+    it "destroys an extraneous file from the destination w/ :sweep" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil },
+        {:create_call=>0} )
+
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil,
+          'file4'=>{:destroy=>true} },
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "destroys and copies files as needed to synchronize directories" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil,
+          'file4'=>nil,
+          'file6'=>nil },
+        {:create_call=>0} )
+
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file3'=>nil,
+          'file5'=>{:destroy=>true},
+          'dir2/file2'=>{:destroy=>true} },
+        {:create_call=>2} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "uses the remote copy facilities when making duplicates" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'dir2/file1'=>nil,
+          'file4'=>nil },
+        {:create_call=>0} )
+
+      # There are two duplicates, 'file1', in the local store. To save
+      # time/data we just call copy on the file that already exists in
+      # the remote, notice the '0' create_calls.
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file4'=>nil },
+        {:create_call=>0} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "uses the content of the file, not the name to determine equality" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'file4'=>nil },
+        {:create_call=>0} )
+
+      # :munge_body cause the MD5 sum to mismatch the file name
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>{:munge_body=>true,:destroy=>true},
+          'dir1/file2'=>nil,
+          'file4'=>nil },
+        {:create_call=>1} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+
+    it "uses create AND duplicate routines with multiple new identical files" do
+      src_storage = make_storage(
+        'foo',
+        { 'dir1/file1'=>nil,
+          'dir1/file2'=>nil,
+          'dir2/dir3/file2'=>nil,
+          'file2'=>nil },
+        {:create_call=>0} )
+
+      # First copy of file1 will use create, the rest will be duped
+      dest_storage = make_storage(
+        'bar',
+        { 'dir1/file1'=>nil },
+        {:create_call=>1} )
+
+      RightPublish::Storage.sync_dirs(src_storage, dest_storage, :sweep=>true)
+      storage_match?(src_storage, dest_storage).should be_true
+    end
+  end
+
+end