cloud_encrypted_sync 0.1.1 → 0.1.2

data/Gemfile.lock

@@ -9,7 +9,7 @@ GEM
     activesupport (3.2.3)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    fakefs (0.4.0)
+    fakefs (0.4.1)
     i18n (0.6.0)
     metaclass (0.0.1)
     mocha (0.11.4)

data/bin/ces

@@ -2,4 +2,4 @@
 require 'optparse'
 require 'etc'
 require File.expand_path('../../lib/cloud_encrypted_sync', __FILE__)
-CloudEncryptedSync::Master.activate!
+CloudEncryptedSync::Synchronizer.run

data/lib/cloud_encrypted_sync/adapter_template.rb

@@ -38,14 +38,11 @@ module CloudEncryptedSync
 
         def register_subclass_with_parent(subclass)
           name = formated_name_of(subclass)
-          if children[name]
-            raise Errors::RegistrationError.new("#{name} already registered")
-          else
-            children[name] = subclass
-          end
+          children[name] ||= subclass
         end
 
         def formated_name_of(subclass)
+          puts "Subclass: #{subclass}"
           subclass.name.match(/([^:]+)$/)[0].underscore.to_sym
         end
       end

data/lib/cloud_encrypted_sync/configuration.rb

@@ -57,7 +57,7 @@ module CloudEncryptedSync
 
         @option_parser = OptionParser.new do |opts|
           opts.banner = "Usage: #{executable_name} [options] /path/to/folder/to/sync"
-          opts.on('--data-dir PATH',"Data directory where snapshots and config file are found.") do |path|
+          opts.on('--data-dir PATH',"Data directory where indexes and config file are found.") do |path|
             clo[:data_dir] = path
           end
           opts.on('--adapter ADAPTERNAME', 'Name of cloud adapter to use.') do |adapter_name|

data/lib/cloud_encrypted_sync/cryptographer.rb

@@ -4,7 +4,6 @@ module CloudEncryptedSync
 
     class << self
 
-
       def encrypt_data(data)
         iv = generate_random_iv
         encrypted_data = crypt_data(:encrypt, iv, data)
@@ -21,10 +20,6 @@ module CloudEncryptedSync
         Digest::SHA2.hexdigest(data,512)
       end
 
-      def generate_random_key
-        initialized_cipher.random_key.unpack('H*')[0]
-      end
-
       #######
       private
       #######

data/lib/cloud_encrypted_sync/dummy_adapter.rb

@@ -5,12 +5,12 @@ module CloudEncryptedSync
       class << self
 
         def write(data,key)
-          stored_data[key] = data
+          stored_data[bucket_name][key] = data
         end
 
         def parse_command_line_options(opts,command_line_options)
           opts.on('--bucket BUCKETNAME', 'Name of cloud adapter to use.') do |bucket_name|
-            command_line_options[:bucket_name] = bucket_name
+            command_line_options[:bucket] = bucket_name
           end
           return command_line_options
         end
@@ -37,7 +37,7 @@ module CloudEncryptedSync
         end
 
         def bucket_name
-          Configuration.settings[:bucket_name].to_sym
+          Configuration.settings[:bucket].to_sym
         end
 
       end

data/lib/cloud_encrypted_sync/errors.rb

@@ -1,6 +1,5 @@
 module CloudEncryptedSync
   module Errors
-    class RegistrationError < RuntimeError; end
     class IncompleteConfigurationError < RuntimeError; end
     class NoSuchKey < RuntimeError; end
     class TemplateMethodCalled < RuntimeError; end

data/lib/cloud_encrypted_sync/index.rb

@@ -18,15 +18,15 @@ module CloudEncryptedSync
       def write
         local_hash = compile_local_hash #recompile
         liaison.push(local_hash.to_yaml,index_key) #push to remote
-        File.open(snapshot_path, 'w') { |file| YAML.dump(local_hash, file) } #save to local
+        File.open(index_path, 'w') { |file| YAML.dump(local_hash, file) } #save to local
       end
 
       def full_file_path(relative_path)
-        normalized_sync_path+'/'+relative_path
+        normalized_sync_path+relative_path
       end
 
-      def snapshot_path
-        "#{Configuration.data_folder_path}/#{snapshot_filename}"
+      def index_path
+        "#{Configuration.data_folder_path}/#{index_filename}"
       end
 
       def file_key(full_path)
@@ -60,7 +60,7 @@ module CloudEncryptedSync
         @index_key ||= Cryptographer.hash_data(Configuration.settings[:encryption_key])
       end
 
-      def snapshot_filename
+      def index_filename
         "#{normalized_sync_path.gsub(/[^A-Za-z0-9]/,'_')}.index.yml"
       end
 

data/lib/cloud_encrypted_sync/{master.rb → synchronizer.rb}

@@ -1,27 +1,23 @@
 module CloudEncryptedSync
-  class Master
+  class Synchronizer
 
     class << self
       attr_accessor :finalize_required
 
-      def activate!
-        sync
-      end
-
-      def sync
+      def run
         begin
-          CloudEncryptedSync::Master.delete_local_files!
-          CloudEncryptedSync::Master.delete_remote_files!
-          CloudEncryptedSync::Master.pull_files!
-          CloudEncryptedSync::Master.push_files!
-          CloudEncryptedSync::Master.finalize!
+          delete_local_files
+          delete_remote_files
+          pull_files
+          push_files
+          finalize
         rescue Errors::IncompleteConfigurationError => exception
           puts exception.message
         end
       end
 
-      def push_files!
-        progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pushing Files: ')
+      def push_files
+        progress_meter = ProgressMeter.new(files_to_push.keys.size,:label => 'Pushing Files: ')
         pushed_files_counter = 0
         files_to_push.each_pair do |key,relative_path|
           puts #newline for progress meter
@@ -38,7 +34,7 @@ module CloudEncryptedSync
         end
       end
 
-      def pull_files!
+      def pull_files
         progress_meter = ProgressMeter.new(files_to_pull.keys.size,:label => 'Pulling Files: ')
         pulled_files_counter = 0
         files_to_pull.each_pair do |key,relative_path|
@@ -46,7 +42,7 @@ module CloudEncryptedSync
           puts #newline for progress meter
           if File.exist?(full_path) and (Index.file_key(full_path) == key)
             #already exists. probably left over from an earlier aborted pull
-            puts "Not Pulling (already exists): #{path}"
+            puts "Not Pulling (already exists): #{full_path}"
           else
             Dir.mkdir(File.dirname(full_path)) unless File.exist?(File.dirname(full_path))
             puts "Pulling: #{relative_path}"
@@ -62,7 +58,7 @@ module CloudEncryptedSync
         end
       end
 
-      def delete_remote_files!
+      def delete_remote_files
         remote_files_to_delete.each_pair do |key,path|
           puts "Deleting Remote: #{path}"
           liaison.delete(key)
@@ -70,10 +66,10 @@ module CloudEncryptedSync
         end
       end
 
-      def delete_local_files!
+      def delete_local_files
         local_files_to_delete.each_pair do |key,relative_path|
           full_path = Index.full_file_path(relative_path)
-          if !File.exist?(full_path) or (Index.file_key(full_path) == key)
+          if !File.exist?(full_path)
             puts "Not Deleting Local: #{relative_path}"
           else
             puts "Deleting Local: #{relative_path}"
@@ -83,7 +79,7 @@ module CloudEncryptedSync
         end
       end
 
-      def finalize!
+      def finalize
         Index.write if finalize_required
       end
 
@@ -95,12 +91,8 @@ module CloudEncryptedSync
         AdapterLiaison.instance
       end
 
-      def last_sync_date
-        @last_sync_date ||= File.exist?(Index.snapshot_path) ? File.stat(Index.snapshot_path).ctime : nil
-      end
-
       def last_sync_hash
-        @last_sync_hash ||= File.exist?(Index.snapshot_path) ? YAML.load(File.read(Index.snapshot_path)) : {}
+        @last_sync_hash ||= File.exist?(Index.index_path) ? YAML.load(File.read(Index.index_path)) : {}
       end
 
       def files_to_push

data/lib/cloud_encrypted_sync/version.rb

@@ -1,3 +1,3 @@
 module CloudEncryptedSync
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/cloud_encrypted_sync.rb

@@ -1,11 +1,10 @@
-require 'singleton'
-require 'yaml'
-require 'openssl'
+require 'active_support/core_ext/string'
 require 'digest'
+require 'fileutils'
 require 'find'
-require 'active_support/core_ext/string'
-
-require File.expand_path('../cloud_encrypted_sync/master', __FILE__)
+require 'openssl'
+require 'singleton'
+require 'yaml'
 
 require File.expand_path('../cloud_encrypted_sync/adapter_liaison', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/adapter_template', __FILE__)
@@ -14,4 +13,5 @@ require File.expand_path('../cloud_encrypted_sync/cryptographer', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/dummy_adapter', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/errors', __FILE__)
 require File.expand_path('../cloud_encrypted_sync/index', __FILE__)
-require File.expand_path('../cloud_encrypted_sync/progress_meter', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/progress_meter', __FILE__)
+require File.expand_path('../cloud_encrypted_sync/synchronizer', __FILE__)

data/test/test_helper.rb

@@ -13,30 +13,45 @@ require 'cloud_encrypted_sync'
 module CloudEncryptedSync
   class ActiveSupport::TestCase
 
-    setup :activate_fake_fs
-    setup :preset_environment
+    setup :initialize_environment
     setup :capture_stdout
     teardown :deactivate_fake_fs
     teardown :release_stdout
 
-    def preset_environment
-      Configuration.instance_variable_set(:@settings,nil)
-      Configuration.instance_variable_set(:@command_line_options,nil)
-      Index.instance_variable_set(:@local, nil)
-      FileUtils.mkdir_p test_source_folder
-      FileUtils.mkdir_p test_source_folder + '/test_sub_folder'
-      File.open(test_source_folder + '/test_sub_folder/test_file_one.txt', 'w') do |test_file|
-        test_file.write('Test File One')
-      end
+    def initialize_environment
+      initialize_fake_fs
+      stub_configuration
+      Index.instance_variable_set(:@local,nil)
+      Index.instance_variable_set(:@remote,nil)
+    end
+
+    def stub_configuration
+      Configuration.stubs(:settings).returns({
+        :encryption_key => 'asdf',
+        :adapter_name => 'dummy',
+        :bucket => "test-bucket",
+        :sync_path => test_source_folder
+      })
+      Configuration.stubs(:data_folder_path).returns("#{Etc.getpwuid.dir}/.cloud_encrypted_sync")
+    end
+
+    def unstub_configuration
+      Configuration.unstub(:settings)
+      Configuration.unstub(:data_folder_path)
     end
 
     def test_source_folder
       @test_source_folder ||= File.expand_path('../test_folder',  __FILE__)
     end
 
-    def activate_fake_fs
+    def initialize_fake_fs
       FakeFS.activate!
       FakeFS::FileSystem.clear
+      FileUtils.mkdir_p test_source_folder
+      FileUtils.mkdir_p test_source_folder + '/test_sub_folder'
+      File.open(test_source_folder + '/test_sub_folder/test_file_one.txt', 'w') do |test_file|
+        test_file.write('Test File One')
+      end
     end
 
     def deactivate_fake_fs

data/test/unit/adapter_liaison_test.rb

@@ -3,29 +3,50 @@ require 'test_helper'
 module CloudEncryptedSync
   class AdapterLiaisonTest < ActiveSupport::TestCase
 
-    def setup
-      Configuration.stubs(:settings).returns({
-        :encryption_key => 'asdf',
-        :adapter_name => 'dummy',
-        :bucket => "test-bucket",
-        :sync_path => test_source_folder
-      })
-      Configuration.stubs(:data_folder_path).returns("#{Etc.getpwuid.dir}/.cloud_encrypted_sync")
+    test 'should require available adapter' do
+      Dir.stubs(:glob).returns(['/path/cloud_encrypted_sync_first_test_adapter-1.2.3'])
+      assert_raises(LoadError) { AdapterLiaison.clone.instance }
     end
 
     test 'should encrypt when writing' do
       precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
-      key = Cryptographer.hash_data('test_file_key')
-      Adapters::Dummy.expects(:write).with(anything,key).returns(true)
-      AdapterLiaison.instance.push(precrypted_data,key)
+      Cryptographer.expects(:encrypt_data).with(precrypted_data)
+      Adapters::Dummy.expects(:write).with(anything,'test_key')
+      AdapterLiaison.instance.push(precrypted_data,'test_key')
     end
 
     test 'should decrypt_when_reading' do
       precrypted_data = File.read(test_source_folder + '/test_sub_folder/test_file_one.txt')
       encrypted_data = Cryptographer.encrypt_data(precrypted_data)
-      key = Cryptographer.hash_data('test_file_key')
-      Adapters::Dummy.expects(:read).with(key).returns(encrypted_data)
-      assert_equal(precrypted_data,AdapterLiaison.instance.pull(key))
+      Adapters::Dummy.expects(:read).with('test_key').returns(encrypted_data)
+      assert_equal(precrypted_data,AdapterLiaison.instance.pull('test_key'))
+    end
+
+    test 'should forward delete to dummy' do
+      Adapters::Dummy.expects(:delete).with('test_key').returns(true)
+      AdapterLiaison.instance.delete('test_key')
+    end
+
+    test 'should forward key exists to dummy' do
+      Adapters::Dummy.expects(:key_exists?).with('test_key').returns(true)
+      AdapterLiaison.instance.key_exists?('test_key')
+    end
+
+    test 'should find lastest versions of available adapters' do
+      Dir.stubs(:glob).returns([
+        '/path/cloud_encrypted_sync_first_test_adapter-1.2.3',
+        '/path/cloud_encrypted_sync_second_test_adapter-4.5.6',
+        '/path/cloud_encrypted_sync_second_test_adapter-7.8.9'
+      ])
+      assert_equal({'first_test' => '1.2.3', 'second_test' => '7.8.9'}, AdapterLiaison.instance.send(:latest_versions_of_installed_adapters))
+    end
+
+    test 'should exercise dummy adapter for test coverage' do
+      dummy = Adapters::Dummy
+      dummy.write('dummy test data','testkey')
+      assert_equal('dummy test data',dummy.read('testkey'))
+      dummy.delete('testkey')
+      assert_equal(false,dummy.key_exists?('testkey'))
     end
 
   end

data/test/unit/adapter_template_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class AdapterTemplateTest < ActiveSupport::TestCase
+
+    test 'should register with parent class on inheritance' do
+      Adapters::Template.expects(:register_subclass_with_parent).returns(true)
+      Class.new(Adapters::Template)
+    end
+
+    test 'should contain registered adapters' do
+      assert_equal([:dummy],Adapters::Template.children.keys)
+    end
+
+    test 'should raise errors on public methods' do
+
+      method_argument_map = {
+        :parse_command_line_options => [:foo,:bar],
+        :write => [:foo,:bar],
+        :read => :foobar,
+        :delete => :foobar,
+        :key_exists? => :foobar
+      }
+      method_argument_map.each_pair do |method,arguments|
+        assert_raise(Errors::TemplateMethodCalled) { Adapters::Template.send(method,*arguments) }
+      end
+    end
+
+  end
+end

data/test/unit/configuration_test.rb

@@ -4,19 +4,20 @@ module CloudEncryptedSync
   class ConfigurationTest < ActiveSupport::TestCase
 
     def setup
+      unstub_configuration
       Configuration.instance_variable_set(:@command_line_options,nil)
       Configuration.instance_variable_set(:@settings,nil)
       Configuration.instance_variable_set(:@option_parser,nil)
       Object.send(:remove_const,:ARGV) #if defined?(::ARGV)
     end
 
-    test 'should parse command line options' do
+    test 'should load settings' do
       ::ARGV = '--adapter dummy --bucket foobar --data-dir ~/test/folder --encryption-key somestringofcharacters /some/path'.split(/\s/)
       settings = Configuration.settings
       assert_equal('dummy',settings[:adapter_name])
       assert_equal('~/test/folder',settings[:data_dir])
       assert_equal('somestringofcharacters',settings[:encryption_key])
-      assert_equal('foobar',settings[:bucket_name])
+      assert_equal('foobar',settings[:bucket])
     end
 
     test 'should gracefully fail without path in ARGV' do
@@ -24,10 +25,17 @@ module CloudEncryptedSync
       assert_raise(Errors::IncompleteConfigurationError) { Configuration.settings }
     end
 
-    test 'should gracefully fail when not provided encryption_key and vector provided path in ARGV' do
+    test 'should gracefully fail when not provided encryption_key and provided path in ARGV' do
       ::ARGV = '--adapter dummy --bucket foobar /some/path/to/sync'.split(/\s/)
       assert_raise(Errors::IncompleteConfigurationError) { Configuration.settings }
     end
 
+    test 'should create data folder if it does not exist' do
+      ::ARGV = '--adapter dummy --bucket foobar --data-dir /test --encryption-key somestringofcharacters /some/path'.split(/\s/)
+      assert ! File.exist?('/test')
+      Configuration.settings
+      assert File.exist?('/test')
+    end
+
   end
 end

data/test/unit/cryptographer_test.rb

@@ -3,31 +3,16 @@ require 'test_helper'
 module CloudEncryptedSync
   class CryptographerTest < ActiveSupport::TestCase
 
-    def setup
-      Configuration.stubs(:settings).returns({
-        :encryption_key => 'asdf',
-        :adapter_name => 'dummy',
-        :bucket => "test-bucket",
-        :data_dir => "#{Etc.getpwuid.dir}/.cloud_encrypted_sync",
-        :sync_path => test_source_folder
-      })
-    end
-
-    test 'should hash data' do
-      hash = Cryptographer.hash_data('abc123')
-      assert_equal('c70b5dd9ebfb6f51d09d4132b7170c9d20750a7852f00680f65658f0310e810056e6763c34c9a00b0e940076f54495c169fc2302cceb312039271c43469507dc',hash)
-    end
-
     test 'should encrypt and decrypt data' do
-      unencrypted_data = "123xyz"
-      encrypted_data = Cryptographer.encrypt_data(unencrypted_data)
+      precrypted_data = "123xyz"
+      encrypted_data = Cryptographer.encrypt_data(precrypted_data)
       decrypted_data = Cryptographer.decrypt_data(encrypted_data)
-      assert_equal(unencrypted_data,decrypted_data)
+      assert_equal(precrypted_data,decrypted_data)
     end
 
-    test 'test should generate random key' do
-      assert_equal(String,Cryptographer.generate_random_key.class)
+    test 'should hash data' do
+      hashed_data = Cryptographer.hash_data('abc123')
+      assert_equal(128,hashed_data.length)
     end
-
   end
 end

data/test/unit/index_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class IndexTest < ActiveSupport::TestCase
+
+    test 'should compile local directory hash' do
+      assert_equal('',$stdout.string)
+      hash = Index.local
+      assert_equal(1,hash.keys.size)
+      assert_equal('test_sub_folder/test_file_one.txt',hash[hash.keys.first])
+      assert_match(/\% Complete/,$stdout.string)
+    end
+
+    test 'should fetch remote directory hash' do
+      AdapterLiaison.instance.expects(:pull).returns({:some => 'hash'}.to_yaml)
+      assert_equal({:some => 'hash'},Index.remote)
+    end
+
+    test 'should return empty hash if no remote index' do
+      Index.instance_variable_set(:@remote,nil)
+      AdapterLiaison.instance.expects(:pull).raises(Errors::NoSuchKey)
+      assert_equal({},Index.remote)
+    end
+
+    test 'should recompile and write local and remote hashes' do
+      Configuration.send(:touch_data_folder)
+      AdapterLiaison.instance.expects(:push)
+      FakeFS::File.any_instance.expects(:read).returns('Testing 123')
+      Index.write
+    end
+
+    test 'should return full normalized file path' do
+      assert_match(/.+\/test\/test_folder\/foobar$/,Index.full_file_path('foobar'))
+    end
+
+    test 'should leave sync path unchanged' do
+      Configuration.stubs(:settings).returns({:sync_path => '/foo/bar/'})
+      assert_equal('/foo/bar/',Index.send(:normalize_sync_path))
+    end
+
+    test 'should add trailing slash to sync path' do
+      Configuration.stubs(:settings).returns({:sync_path => '/foo/bar'})
+      assert_equal('/foo/bar/',Index.send(:normalize_sync_path))
+    end
+
+  end
+end

data/test/unit/synchronizer_test.rb

@@ -0,0 +1,169 @@
+require 'test_helper'
+
+module CloudEncryptedSync
+  class SynchronizerTest < ActiveSupport::TestCase
+
+    SYNC_METHODS = [:delete_local_files, :delete_remote_files, :push_files, :pull_files, :finalize]
+
+    test 'should run full sync' do
+      SYNC_METHODS.each { |method_name| Synchronizer.expects(method_name) }
+
+      Synchronizer.run
+    end
+
+    test 'should puts error message to stdout when config is incomplete' do
+      Configuration.stubs(:settings).raises(Errors::IncompleteConfigurationError,'test message')
+      AdapterLiaison.expects(:push).never
+      AdapterLiaison.expects(:pull).never
+
+      assert_equal('',$stdout.string)
+      Synchronizer.run
+      assert_match(/test message/,$stdout.string)
+    end
+
+    test 'should push files' do
+      Adapters::Dummy.expects(:write)
+
+      assert_equal('',$stdout.string)
+      Synchronizer.push_files
+      assert_match(/\% Complete/,$stdout.string)
+    end
+
+    test 'should not push files that already exist' do
+      AdapterLiaison.instance.stubs(:key_exists?).returns(true)
+      Synchronizer.push_files
+      assert_match(/\(already exists\)/,$stdout.string)
+    end
+
+    test 'should pull files' do
+      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
+      Adapters::Dummy.expects(:read).with('new_file_key').returns(Cryptographer.encrypt_data('foobar'))
+      assert_equal('',$stdout.string)
+      assert_difference('Dir["#{test_source_folder}/**/*"].length') do
+        Synchronizer.pull_files
+      end
+      assert_match(/\% Complete/,$stdout.string)
+    end
+
+    test 'should not pull files that already exist' do
+      Synchronizer.stubs(:files_to_pull).returns({:foo => 'bar'})
+      File.stubs(:exist?).returns(true)
+      Index.stubs(:file_key).returns(:foo)
+      Synchronizer.pull_files
+      assert_match(/\(already exists\)/,$stdout.string)
+    end
+
+    test 'should gracefully recover if pull fails' do
+      Synchronizer.stubs(:files_to_pull).returns({:foo => 'bar'})
+      AdapterLiaison.instance.stubs(:pull).raises(Errors::NoSuchKey)
+      Synchronizer.pull_files
+      assert_match(/Failed to pull/,$stdout.string)
+    end
+
+    test 'should delete files from cloud' do
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Synchronizer.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
+      Adapters::Dummy.expects(:delete).with('deleted_file_key').returns(true)
+      Synchronizer.delete_remote_files
+      assert_match(/Deleting Remote/,$stdout.string)
+    end
+
+    test 'should delete local files' do
+      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
+      Synchronizer.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'}.merge(Index.local))
+      assert_difference('Dir["#{test_source_folder}/**/*"].length',-1) do
+        Synchronizer.delete_local_files
+      end
+      assert_match(/Deleting Local/,$stdout.string)
+    end
+
+    test 'should gracefully recover if local file disappears before delete' do
+      Synchronizer.stubs(:local_files_to_delete).returns({:foo => 'bar'})
+      File.stubs(:exist?).returns(false)
+      Synchronizer.delete_local_files
+      assert_match(/Not Deleting Local/,$stdout.string)
+    end
+
+    test 'should finalize' do
+      Synchronizer.instance_variable_set(:@finalize_required,true)
+      Index.expects(:write)
+
+      Synchronizer.finalize
+    end
+
+    test 'should want to push everything on first run with local files and empty remote' do
+      Index.stubs(:remote).returns({})
+      Index.stubs(:local).returns({"new_file_key"=>"test_sub_folder/new_file.txt"})
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal(Index.local,Synchronizer.send(:files_to_push))
+    end
+
+    test 'should want to push new files with available last sync hash' do
+      new_file_hash = {"new_file_key"=>"test_sub_folder/new_file.txt"}
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"}.merge(new_file_hash))
+      Synchronizer.stubs(:last_sync_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      assert_equal(new_file_hash,Synchronizer.send(:files_to_push))
+    end
+
+    test 'should want to push new files with local and remote files and empty last sync hash' do
+      new_file_hash = {"new_file_key"=>"test_sub_folder/new_file.txt"}
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"}.merge(new_file_hash))
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal(new_file_hash,Synchronizer.send(:files_to_push))
+    end
+
+    test 'should want to puull everything on first run with no local files and remote files available' do
+      Index.stubs(:remote).returns({"new_file_key"=>"test_sub_folder/new_file.txt"})
+      Index.stubs(:local).returns({})
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal(Index.remote,Synchronizer.send(:files_to_pull))
+    end
+
+    test 'should want to pull new files with available last sync hash' do
+      new_file_hash = {"new_file_key"=>"test_sub_folder/new_file.txt"}
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"}.merge(new_file_hash))
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Synchronizer.stubs(:last_sync_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      assert_equal(new_file_hash,Synchronizer.send(:files_to_pull))
+    end
+
+    test 'should want to pull new files with local and remote files and empty last sync hash' do
+      new_file_hash = {"new_file_key"=>"test_sub_folder/new_file.txt"}
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"}.merge(new_file_hash))
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal(new_file_hash,Synchronizer.send(:files_to_pull))
+    end
+
+    test 'should not want to delete remote files if last sync hash is empty' do
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Index.stubs(:local).returns({})
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal({},Synchronizer.send(:remote_files_to_delete))
+    end
+
+    test 'should want to delete remote files' do
+      Index.stubs(:remote).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Index.stubs(:local).returns({})
+      Synchronizer.stubs(:last_sync_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      assert_equal(Index.remote,Synchronizer.send(:remote_files_to_delete))
+    end
+
+    test 'should not want to delete local files if last sync hash is empty' do
+      Index.stubs(:remote).returns({})
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Synchronizer.stubs(:last_sync_hash).returns({})
+      assert_equal({},Synchronizer.send(:local_files_to_delete))
+    end
+
+    test 'should want to delete local files' do
+      Index.stubs(:remote).returns({})
+      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      Synchronizer.stubs(:last_sync_hash).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
+      assert_equal(Index.local,Synchronizer.send(:local_files_to_delete))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloud_encrypted_sync
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-16 00:00:00.000000000 Z
+date: 2012-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
@@ -100,15 +100,17 @@ files:
 - lib/cloud_encrypted_sync/dummy_adapter.rb
 - lib/cloud_encrypted_sync/errors.rb
 - lib/cloud_encrypted_sync/index.rb
-- lib/cloud_encrypted_sync/master.rb
 - lib/cloud_encrypted_sync/progress_meter.rb
+- lib/cloud_encrypted_sync/synchronizer.rb
 - lib/cloud_encrypted_sync/version.rb
 - test/test_helper.rb
 - test/unit/adapter_liaison_test.rb
+- test/unit/adapter_template_test.rb
 - test/unit/configuration_test.rb
 - test/unit/cryptographer_test.rb
-- test/unit/master_test.rb
+- test/unit/index_test.rb
 - test/unit/progress_meter_test.rb
+- test/unit/synchronizer_test.rb
 homepage: https://github.com/jsgarvin/cloud_encrypted_sync
 licenses: []
 post_install_message: 
@@ -136,7 +138,9 @@ summary: Encrypted sync of folder contents to/from cloud storage.
 test_files:
 - test/test_helper.rb
 - test/unit/adapter_liaison_test.rb
+- test/unit/adapter_template_test.rb
 - test/unit/configuration_test.rb
 - test/unit/cryptographer_test.rb
-- test/unit/master_test.rb
+- test/unit/index_test.rb
 - test/unit/progress_meter_test.rb
+- test/unit/synchronizer_test.rb

data/test/unit/master_test.rb

@@ -1,138 +0,0 @@
-require 'test_helper'
-
-module CloudEncryptedSync
-  class MasterTest < ActiveSupport::TestCase
-
-    def setup
-      Configuration.stubs(:settings).returns({
-        :encryption_key => 'asdf',
-        :adapter_name => 'dummy',
-        :bucket => "test-bucket",
-        :sync_path => test_source_folder
-      })
-      Configuration.stubs(:data_folder_path).returns("#{Etc.getpwuid.dir}/.cloud_encrypted_sync")
-    end
-
-    test 'should generate directory hash' do
-      assert_equal('',$stdout.string)
-      hash = Index.local
-      assert_equal(1,hash.keys.size)
-      assert_equal('test_sub_folder/test_file_one.txt',hash[hash.keys.first])
-      assert_match(/\% Complete/,$stdout.string)
-    end
-
-    test 'should_return_nil_if_never_synced_before' do
-      Master.stubs(:snapshot_file_path).returns('/non/existant/file')
-      assert_equal(nil,Master.send(:last_sync_date))
-    end
-
-    test 'should want to push everything on first run with local files and empty remote' do
-      Index.stubs(:remote).returns({})
-      Index.stubs(:local).returns({"old_file_key"=>"test_sub_folder/old_file.txt"})
-      Master.stubs(:last_sync_hash).returns({})
-      assert_equal(Index.local,Master.send(:files_to_push))
-    end
-
-    test 'should push files' do
-      Master.stubs(:remote_directory_hash).returns({})
-      Master.stubs(:last_sync_hash).returns({})
-      Adapters::Dummy.stubs(:key_exists?).returns(false)
-      Adapters::Dummy.expects(:write).with(any_parameters).returns(true)
-      assert_equal('',$stdout.string)
-      Master.push_files!
-      assert_match(/\% Complete/,$stdout.string)
-    end
-
-    test 'should want to pull everything on first run with remote files and empty local' do
-      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
-      Index.stubs(:local).returns({})
-      Master.stubs(:last_sync_hash).returns({})
-      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
-    end
-
-    test 'should pull files' do
-      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt'})
-      Index.stubs(:local).returns({})
-      Master.stubs(:last_sync_hash).returns({})
-      Adapters::Dummy.expects(:read).with('new_file_key').returns(Cryptographer.encrypt_data('foobar'))
-      assert_equal('',$stdout.string)
-      assert_difference('Dir["#{test_source_folder}/**/*"].length') do
-        Master.pull_files!
-      end
-      assert_match(/\% Complete/,$stdout.string)
-    end
-
-    test 'should only want to push new files on later run' do
-      Index.stubs(:remote).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Index.stubs(:local).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
-      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_push))
-    end
-
-    test 'should want to pull new files from cloud' do
-      Index.stubs(:remote).returns({'new_file_key' => 'test_sub_folder/new_file.txt', 'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Index.stubs(:local).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'old_file_key' => 'test_sub_folder/old_file.txt'})
-      assert_equal({'new_file_key' => 'test_sub_folder/new_file.txt'},Master.send(:files_to_pull))
-    end
-
-    test 'should want to delete locally missing files from cloud' do
-      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:remote_files_to_delete))
-    end
-
-    test 'should delete files from cloud' do
-      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Adapters::Dummy.expects(:delete).with('deleted_file_key').returns(true)
-      Master.delete_remote_files!
-    end
-
-    test 'should want to delete appropriate files locally' do
-      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Index.stubs(:local).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'})
-      assert_equal({'deleted_file_key' => 'test_sub_folder/deleted_file.txt'},Master.send(:local_files_to_delete))
-    end
-
-    test 'should delete local files' do
-      Index.stubs(:remote).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt'})
-      Master.stubs(:last_sync_hash).returns({'saved_file_key' => 'test_sub_folder/saved_file.txt', 'deleted_file_key' => 'test_sub_folder/deleted_file.txt'}.merge(Index.local))
-      assert_difference('Dir["#{test_source_folder}/**/*"].length',-1) do
-        Master.delete_local_files!
-      end
-    end
-
-    test 'should finalize' do
-      FileUtils.mkdir_p(Configuration.data_folder_path)
-      sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
-      Master.instance_variable_set(:@finalize_required,true)
-      Master.stubs(:directory_hash).returns(sample_directory_hash)
-      Adapters::Dummy.expects(:write).with(anything,Index.send(:index_key)).returns(true)
-      Master.finalize!
-    end
-
-    test 'should decrypt remote directory file' do
-      #setup mock data
-      sample_directory_hash = {'sample_file_key' => 'test_sub_folder/sample_file.txt'}
-      encrypted_directory_hash = Cryptographer.encrypt_data(sample_directory_hash.to_yaml)
-      Adapters::Dummy.expects(:read).with(Index.send(:index_key)).returns(encrypted_directory_hash)
-
-      #do actual test
-      decrypted_remote_hash = Index.remote
-      assert_equal(sample_directory_hash,decrypted_remote_hash)
-    end
-
-    test 'should puts error message to stdout' do
-      Configuration.stubs(:settings).raises(Errors::IncompleteConfigurationError,'test message')
-      assert_equal('',$stdout.string)
-      Master.expects(:pull_files).never
-      Master.sync
-      assert_match(/test message/,$stdout.string)
-    end
-
-  end
-end