nsync 0.0.2

data/test/active_record_test.rb

@@ -0,0 +1,153 @@
+require File.join(File.dirname(__FILE__), "helper")
+
+gem "activerecord", "~> 2.3.5"
+require 'active_record'
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.send(:extend, Nsync::ActiveRecord::ClassMethods)
+
+class TestFoo < ActiveRecord::Base
+  nsync_producer :if => lambda{|o| o.should_save }
+end
+
+class TestBar < ActiveRecord::Base
+  nsync_consumer
+
+  def should_save=(val)
+    val
+  end
+end
+
+class TestVersion < ActiveRecord::Base
+  def self.version
+    scoped(:order => "id DESC").first.try(:commit_id) || "0"*40
+  end
+
+  def self.version=(commit_id)
+    create(:commit_id => commit_id)
+  end
+
+  def self.previous_version
+    previous_versions_raw.first.commit_id
+  end
+
+  def self.previous_versions
+    previous_versions_raw.map(&:commit_id)
+  end
+
+  def self.previous_versions_raw
+    scoped(:order => "id DESC", :offset => 1)
+  end
+end
+
+
+class ActiveRecordTest < Test::Unit::TestCase
+  class MyConsumer < Nsync::Consumer
+    def self.config
+      @config ||= Nsync::Config.new
+    end
+    def config
+      self.class.config
+    end
+  end
+
+  class MyProducer < Nsync::Producer
+    def self.config
+      @config ||= Nsync::Config.new
+    end
+    def config
+      self.class.config
+    end
+  end
+
+  def setup
+    #Grit.debug = true
+    ActiveRecord::Base.connection.create_table :test_versions, :force => true do |t|
+      t.string :commit_id
+      t.timestamps
+    end
+    ActiveRecord::Base.connection.create_table :test_foos, :force => true do |t|
+      t.string :val
+      t.boolean :should_save
+      t.timestamps
+    end
+
+    ActiveRecord::Base.connection.create_table :test_bars, :force => true do |t|
+      t.integer :source_id
+      t.string :val
+      t.timestamps
+    end
+
+    FileUtils.rm_rf TestRepo.repo_path
+    MyProducer.config.repo_path = TestRepo.repo_path
+    FileUtils.rm_rf TestRepo.repo_push_path
+    Grit::Repo.init_bare(TestRepo.repo_push_path)
+    MyProducer.config.repo_push_url = TestRepo.repo_push_path
+    MyProducer.config.version_manager = Nsync::GitVersionManager.new(TestRepo.repo_path)
+    
+    MyConsumer.config.repo_url = MyProducer.config.repo_push_url
+    FileUtils.rm_rf TestRepo.bare_consumer_repo_path
+    MyConsumer.config.repo_path = TestRepo.bare_consumer_repo_path
+    MyConsumer.config.version_manager = TestVersion
+    MyConsumer.config.map_class "TestFoo", "TestBar"
+
+    FileUtils.rm(MyProducer.config.lock_file, :force => true)
+
+  end
+
+  def test_integration
+    @producer = MyProducer.new
+    #dirty, dirty, dirty hack
+    Nsync.config.producer_instance = @producer
+    @consumer = MyConsumer.new
+
+    first_foo = TestFoo.create(:val => "This should be consumed", :should_save => true)
+    unsaved_foo = TestFoo.create(:val => "This should not be", :should_save => false)
+
+    assert File.exists?(File.join(MyProducer.config.repo_path, first_foo.nsync_filename))
+    assert !File.exists?(File.join(MyProducer.config.repo_path, unsaved_foo.nsync_filename))
+
+    @producer.commit("First objects")
+
+    @consumer.update
+
+    assert_equal 1, TestBar.count
+    assert_equal "This should be consumed", TestBar.nsync_find(first_foo.id).first.val
+
+    unsaved_foo.update_attributes(:should_save => true, :val => "consumption time")
+    
+    assert File.exists?(File.join(MyProducer.config.repo_path, unsaved_foo.nsync_filename))
+    
+    @producer.commit("oh yeah")
+
+    @consumer.update
+
+    assert_equal 2, TestBar.count
+
+    first_foo.update_attributes(:should_save => false, :val => "this is now gone")
+
+    assert !File.exists?(File.join(MyProducer.config.repo_path, first_foo.nsync_filename))
+
+    @producer.commit("we got rid of one")
+
+    @consumer.update
+
+    assert_equal 1, TestBar.count
+    assert_equal unsaved_foo.id, TestBar.first.source_id
+
+    @producer.rollback
+
+    assert File.exists?(File.join(MyProducer.config.repo_path, first_foo.nsync_filename))
+
+    @consumer.update
+
+    assert_equal 2, TestBar.count
+
+    @consumer.rollback
+
+    assert_equal 1, TestBar.count
+
+    @consumer.update
+
+    assert_equal 2, TestBar.count
+  end
+end

data/test/classes.rb

@@ -0,0 +1,22 @@
+class NsyncTestFoo; end
+class NsyncTestBar; end
+
+class NsyncTestVersion
+  class << self
+    def version
+      puts "version: #{@version}"
+      @version
+    end
+  
+    def previous_version
+      @previous_version
+    end
+  
+    def version=(id)
+      puts "updated version: #{id}"
+      @previous_version = @version
+      @version = id
+    end
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "..", "lib", "nsync")
+
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'shoulda'
+require 'redgreen'
+
+require File.join(File.dirname(__FILE__), "repo")
+require File.join(File.dirname(__FILE__), "classes")
+
+

data/test/nsync_config_test.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), "helper")
+
+class NsyncConfigTest < Test::Unit::TestCase
+  def setup
+    Nsync.reset_config
+    @repo_path = "/foo/bar"
+    @repo_url = "http://example.com/foo/bar.git"
+  end
+
+  context "Basic Configuration" do
+    context "for local configuration" do
+      setup do
+        Nsync::Config.run do |config|
+          config.repo_path = @repo_path
+        end
+      end
+  
+      should "set repo_path" do
+        assert_equal @repo_path, Nsync.config.repo_path
+      end
+
+      should "set local?" do
+        assert_equal true, Nsync.config.local?
+      end
+
+      should "set remote?" do
+        assert_equal false, Nsync.config.remote?
+      end
+    end
+
+    context "for remote configuration" do
+      setup do
+        Nsync::Config.run do |config|
+          config.repo_path = @repo_path
+          config.repo_url = @repo_url
+        end
+      end
+
+      should "set repo_path" do
+        assert_equal @repo_path, Nsync.config.repo_path
+      end
+
+      should "set repo_url" do
+        assert_equal @repo_url, Nsync.config.repo_url
+      end
+
+      should "set local?" do
+        assert_equal false, Nsync.config.local?
+      end
+
+      should "set remote?" do
+        assert_equal true, Nsync.config.remote?
+      end
+    end
+  end
+
+  context "Class Mapping" do
+    setup do
+      Nsync.config.map_class "NsyncTestFoo", "NsyncTestBar"
+      Nsync.config.map_class "NsyncTestFoo", "NsyncTestFoo"
+      Nsync.config.map_class "NsyncTestBar", "NsyncTestBar"
+    end
+
+    should "map classes according to the defined mapping in order" do
+      assert_equal [NsyncTestBar, NsyncTestFoo], Nsync.config.consumer_classes_for("NsyncTestFoo")
+      assert_equal [NsyncTestBar], Nsync.config.consumer_classes_for("NsyncTestBar")
+    end
+
+    should "return empty list for undefined mapping" do
+      assert_equal [], Nsync.config.consumer_classes_for("NsyncTestBaz")
+    end
+  end
+
+  context "Lock" do
+    setup do
+      @lock_file = "/private/tmp/nsync_test_#{Process.pid}.lock"
+      FileUtils.rm @lock_file, :force => true
+      Nsync.config.lock_file = @lock_file
+    end
+    
+    context "unlocked" do
+      should "return the value of the block" do
+        ret = Nsync.config.lock do
+          "Success"
+        end
+        assert_equal "Success", ret
+      end
+
+      should "remove the lock file" do
+        assert(Nsync.config.lock do
+          true
+        end)
+        assert !File.exists?(@lock_file)
+      end
+    end
+
+    context "locked" do
+      setup do
+        FileUtils.touch @lock_file
+        #silence warnings
+        Nsync.config.log = ::Logger.new("/dev/null")
+      end
+
+      should "return false" do
+        ret = Nsync.config.lock do
+          true
+        end
+        assert_equal false, ret
+      end
+
+      should "not remove the lock file" do
+        assert(!Nsync.config.lock do
+          true
+        end)
+        assert File.exists? @lock_file
+      end
+    end
+  end
+
+  context "Version Manager" do
+    context "when unassigned" do
+      setup do
+        Nsync.config.version_manager = nil
+      end
+      should "raise an error" do
+        assert_raise RuntimeError do
+          Nsync.config.version_manager
+        end
+      end
+    end
+
+    context "when assigned" do
+      setup do
+        Nsync.config.version_manager = true
+      end
+
+      should "return it" do
+        assert Nsync.config.version_manager
+      end
+    end
+  end
+end

data/test/nsync_consumer_test.rb

@@ -0,0 +1,260 @@
+require File.join(File.dirname(__FILE__), "helper")
+
+class NsyncConsumerTest < Test::Unit::TestCase
+  def setup
+    Nsync.reset_config
+    #Grit.debug = true
+    @lock_file = "/private/tmp/nsync_test_#{Process.pid}.lock"
+    FileUtils.rm @lock_file, :force => true
+    Nsync.config.lock_file = @lock_file
+
+    Nsync.config.version_manager = stub(:version => "foo", :previous_version => "bar")
+    Nsync.config.version_manager.stubs(:version=).with(is_a(String))
+
+    # I think mocha is doing something evil and redefing clone
+    if Grit::Git.instance_methods.include?("clone")
+      Grit::Git.send(:undef_method, :clone)
+    end
+  end
+
+  context "Initializing Consumer" do
+    context "when the repo already exists" do
+      setup do
+        @repo = TestRepo.new
+        FileUtils.rm_rf @repo.bare_consumer_repo_path
+
+        Nsync.config.repo_url = @repo.repo_path
+        Nsync.config.repo_path = @repo.bare_consumer_repo_path
+
+        @consumer = Nsync::Consumer.new
+      end
+
+      should "not reclone it" do
+        Grit::Git.any_instance.expects(:clone).never
+        @consumer = Nsync::Consumer.new
+      end
+    end
+        
+    context "for a local repo" do
+      setup do
+        Nsync.config.repo_url = nil
+      end
+
+      context "that doesn't exist" do
+        setup do
+          @repo_path = "/private/tmp/nsync_non_existent_test_repo"
+          FileUtils.rm_rf @repo_path
+  
+          Nsync.config.repo_path = @repo_path
+        end
+  
+        should "raise a NoSuchPath error" do
+          assert_raise Grit::NoSuchPathError do
+            Nsync::Consumer.new
+          end
+        end
+      end
+
+      context "that does exist" do
+        setup do
+          @repo = TestRepo.new
+          Nsync.config.repo_path = @repo.repo_path
+          @consumer = Nsync::Consumer.new
+        end
+
+        should "assign it to repo" do
+          assert @consumer.repo.is_a? Grit::Repo
+        end
+      end 
+    end
+
+    context "for a remote repo" do
+      context "where the origin does not exist" do
+        setup do
+          @repo_url = "/private/tmp/nsync_non_existent_test_repo"
+          @repo_path = "/private/tmp/nsync_non_existent_test_repo_consumer.git"
+          FileUtils.rm_rf @repo_url
+          FileUtils.rm_rf @repo_path
+
+          Nsync.config.repo_url = @repo_url
+          Nsync.config.repo_path = @repo_path
+        end
+
+        should "raise a NoSuchPath error" do
+          assert_raise Grit::NoSuchPathError do
+            Nsync::Consumer.new
+          end
+        end
+      end
+
+      context "where the origin does exist" do
+        setup do
+          @repo = TestRepo.new
+          FileUtils.rm_rf @repo.bare_consumer_repo_path
+
+          Nsync.config.repo_url = @repo.repo_path
+          Nsync.config.repo_path = @repo.bare_consumer_repo_path
+
+          @consumer = Nsync::Consumer.new
+        end
+
+        should "assign repo to a new bare repo" do
+          assert @consumer.repo.is_a? Grit::Repo
+          assert @consumer.repo.bare
+        end
+      end
+    end  
+  end
+
+  context "Updating the Consumer side" do
+    setup do
+      @repo = TestRepo.new
+      Nsync.config.version_manager.stubs(:version => "HEAD^1")
+      FileUtils.rm_rf @repo.bare_consumer_repo_path
+    end
+
+    context "when local" do
+      setup do
+        Nsync.config.repo_url = nil
+        Nsync.config.repo_path = @repo.repo_path
+
+        @consumer = Nsync::Consumer.new
+        @consumer.expects(:apply_changes).once
+      end
+
+      should "not try to fetch in changes" do
+        @consumer.repo.expects(:remote_fetch).never
+          Grit::Git.any_instance.expects(:reset).never
+        @consumer.update
+      end
+    end
+
+    context "when remote" do
+      setup do
+        Nsync.config.repo_url = @repo.repo_path
+        Nsync.config.repo_path = @repo.bare_consumer_repo_path
+
+        @consumer = Nsync::Consumer.new
+      end
+
+      context "when updating the repo" do
+        should "fetch from origin" do
+          @consumer.expects(:apply_changes).once
+          @consumer.repo.expects(:remote_fetch).once
+          Grit::Git.any_instance.expects(:reset).once
+          @consumer.update
+        end
+      end
+
+      context "with ordering" do
+        setup do
+          changeset = {NsyncTestFoo => ["changes"], NsyncTestBar => ["changes"]}
+
+          order = states('order').starts_as('bar')
+
+          Nsync.config.ordering = ["NsyncTestBar", "NsyncTestFoo"]
+          @consumer.repo.expects(:diff).returns(:diffs).once
+          @consumer.expects(:changeset_from_diffs).with(:diffs).returns(changeset).once
+
+          @consumer.expects(:apply_changes_for_class).when(order.is('bar')).with(NsyncTestBar, ["changes"]).then(order.is('foo')).once
+          @consumer.expects(:apply_changes_for_class).when(order.is('foo')).with(NsyncTestFoo, ["changes"]).then(order.is('final')).once
+        end
+
+        should "execute in specified order" do
+          @consumer.update
+        end
+      end
+
+      context "with callbacks" do
+        setup do
+          Nsync.config.clear_class_mappings
+          Nsync.config.map_class "Foo", "NsyncTestFoo"
+          Nsync.config.map_class "Bar", "NsyncTestBar"
+          Nsync.config.version_manager = NsyncTestVersion
+          NsyncTestVersion.version = @repo.repo.head.commit.id
+
+          Nsync.config.ordering = ["NsyncTestBar", "NsyncTestFoo"]
+          @consumer.send(:clear_queues)
+          @consumer.expects(:clear_queues).twice
+        end
+
+        should "work" do
+          @repo.add_file("foo/1.json", {:id => 1, :val => "Party"})
+          NsyncTestFoo.expects(:nsync_find).with('1').returns([]).once
+          NsyncTestFoo.expects(:nsync_add_data).once.with(@consumer, :added, is_a(String), has_entry("val", "Party")) 
+          @repo.add_file("bar/2.json", {:id => 2, :val => "Hardy"})
+          @repo.commit("Added some objects")
+          NsyncTestFoo.expects(:nsync_find).never
+          mock_bar = mock
+          mock_bar.expects(:nsync_update).once.with(@consumer, :added, is_a(String), has_entry("val", "Hardy"))
+          NsyncTestBar.expects(:nsync_find).with('2').returns([mock_bar]).once
+
+
+          order = states('order').starts_as('bar')
+
+          NsyncTestFoo.expects(:from_callback).once.when(order.is('foo')).then(order.is('final'))
+          mock_bar.expects(:from_callback).once.when(order.is('bar')).then(order.is('foo'))
+
+          mock_final = mock
+          mock_final.expects(:from_callback).once.when(order.is('final'))
+
+          @consumer.after_class_finished(NsyncTestFoo, lambda { NsyncTestFoo.from_callback })
+          @consumer.after_class_finished(NsyncTestBar, lambda { mock_bar.from_callback })
+
+          @consumer.after_finished(lambda { mock_final.from_callback })
+
+          @consumer.update
+        end
+      end
+
+      context "basic flow" do
+        setup do
+          Nsync.config.clear_class_mappings
+          Nsync.config.map_class "Foo", "NsyncTestFoo"
+          Nsync.config.map_class "Bar", "NsyncTestBar"
+          Nsync.config.version_manager = NsyncTestVersion
+          NsyncTestVersion.version = @repo.repo.head.commit.id
+        end
+
+        should "work" do
+          @repo.add_file("foo/1.json", {:id => 1, :val => "Party"})
+          @repo.commit("Added one object")
+          NsyncTestFoo.expects(:nsync_find).with('1').returns([]).once
+          NsyncTestFoo.expects(:nsync_add_data).once.with(@consumer, :added, is_a(String), has_entry("val", "Party")) 
+          @consumer.update
+
+          @repo.add_file("bar/2.json", {:id => 2, :val => "Hardy"})
+          @repo.commit("And now for the bar")
+          NsyncTestFoo.expects(:nsync_find).never
+          mock_bar = mock
+          mock_bar.expects(:nsync_update).once.with(@consumer, :added, is_a(String), has_entry("val", "Hardy"))
+          NsyncTestBar.expects(:nsync_find).with('2').returns([mock_bar]).once
+          @consumer.update
+
+          @repo.add_file("foo/1.json", {:id => 1, :val => "Party Hardest"})
+          @repo.add_file("bar/3.json", {:id => 3, :val => "Moooooo"})
+          @repo.commit("I changed the foo and added a bar")
+          mock_foo = mock
+          mock_foo.expects(:nsync_update).once.with(@consumer, :modified, is_a(String), has_entry("val", "Party Hardest"))
+          NsyncTestFoo.expects(:nsync_find).with('1').returns([mock_foo]).once
+          NsyncTestBar.expects(:nsync_find).with('3').returns([]).once
+          NsyncTestBar.expects(:nsync_add_data).with(@consumer, :added, is_a(String), has_entry("val", "Moooooo")).once
+          @consumer.update
+
+          @repo.remove_file("foo/1.json")
+          @repo.commit("No more party")
+          mock_foo2 = mock
+          mock_foo2.expects(:nsync_update).with(@consumer, :deleted, is_a(String), {}).once
+          NsyncTestFoo.expects(:nsync_find).with('1').returns([mock_foo2]).once
+          @consumer.update
+
+          NsyncTestFoo.expects(:nsync_find).with('1').returns([]).once
+          NsyncTestFoo.expects(:nsync_add_data).once.with(@consumer, :added, is_a(String), has_entry("val", "Party Hardest")) 
+
+          #bring the party back
+          @consumer.rollback
+        end
+      end
+    end
+  end
+end