hover-ruby-client 0.3.1

data/test/unit/decoder/json_stream_test.rb

@@ -0,0 +1,8 @@
+require './test/test_helper'
+
+require 'hover/decoder/json_stream'
+
+describe Hover::Decoder::JSONStream do
+  let(:instance) { Hover::Decoder::JSONStream.new }
+  
+end

data/test/unit/encoder/json_stream_test.rb

@@ -0,0 +1,135 @@
+require './test/test_helper'
+
+require 'hover/encoder/json_stream'
+
+describe Hover::Encoder::JSONStream do
+  let(:instance) { Hover::Encoder::JSONStream.new }
+
+  let(:attributes) do
+    {'a' => 1, 'b' => 2}
+  end
+
+  it "initializes" do
+    instance.must_be_kind_of(Hover::Encoder::JSONStream)
+  end
+
+  describe "open" do
+    it "sets file" do
+      file = mock
+      File.expects(:open).with("/tmp/filename", 'w').returns(file)
+
+      instance.open("/tmp/filename")
+      instance.file.must_equal(file)
+    end
+  end
+
+  describe "close" do
+    it "closes file" do
+      file = mock
+      file.expects(:close)
+
+      instance.file = file
+      instance.close
+
+      assert_nil instance.file
+    end
+  end
+
+  describe "append" do
+    it "appends" do
+      file = mock
+      file.expects(:puts).with("#{attributes.merge({'class' => 'Hash'}).to_json}")
+
+      instance.file = file
+
+      instance.append(attributes, attributes.class)
+    end
+
+    it "last" do
+      file = mock
+      file.expects(:puts).with("#{attributes.merge({'class' => 'Hash'}).to_json}")
+
+      instance.file = file
+
+      instance.append(attributes, attributes.class)
+    end
+  end
+
+  describe "append_each" do
+    it "appends" do
+      file = mock
+      file.expects(:puts).with("#{attributes.merge({'class' => 'Hash'}).to_json}").twice
+
+      instance.file = file
+
+      instance.append_each([attributes, attributes], attributes.class)
+    end
+  end
+
+  describe "append_records" do
+    it "appends from scope" do
+      TestClass.destroy_all
+
+      a = TestClass.create!
+      b = TestClass.create!
+
+      instance.expects(:append).with(a.attributes, TestClass)
+      instance.expects(:append).with(b.attributes, TestClass)
+
+      instance.append_records(TestClass.all)
+    end
+  end
+
+  describe "valid json" do
+
+    it "avoids NaN problem" do
+      # with PostgreSQL we could use TestClass#a, but sqlite persists the NaN as nil
+      class SpecialStandInForThisTest
+        def find_each
+          yield self
+        end
+        def attributes
+          # if JSONStream doesn't turn this NaN into a nil we'll see an error in parsing the generated JSON
+          nan = 0.0 / 0.0
+          {"foo" => "bar", "x" => nan}
+        end
+      end
+      file = Tempfile.new(['hover-ruby-client_json_encoder-NaN', '.json'])
+      instance.open(file.path)
+      instance.append_records(SpecialStandInForThisTest.new)
+      instance.close
+      JSON.parse(file.read).must_equal({"foo" => "bar", "x" => nil, "class"=>"SpecialStandInForThisTest"})
+    end
+
+    it "works" do
+      file = Tempfile.new(['hover-ruby-client_json_encoder', '.json'])
+
+      begin
+        1.upto(50) do
+          TestClass.create!
+        end
+
+        1.upto(50) do
+          Tag.create!
+        end
+
+        instance.open(file.path)
+        instance.append_records(TestClass.all)
+        instance.append_records(Tag.all)
+        instance.close
+
+        expected = [
+          TestClass.all.map { |test_class| test_class.attributes.merge({'class' => 'TestClass'}) },
+          Tag.all.map { |tag| tag.attributes.merge({'class' => 'Tag'}) },
+        ].flatten
+
+        file.each_line do |line|
+          expected.include?(JSON.parse(line)).must_equal(true)
+        end
+      ensure
+        file.close
+        file.unlink
+      end
+    end
+  end
+end

data/test/unit/importer/active_record_test.rb

@@ -0,0 +1,354 @@
+require './test/test_helper'
+
+require 'hover/importer/active_record'
+require 'active_record'
+
+class TestClass < ActiveRecord::Base
+  belongs_to :item
+
+  def self.s3_file_versions
+    {image: {small: {}}, document: {}}
+  end
+
+  def document_s3_keys=(value)
+    value
+  end
+
+  def image_s3_keys=(value)
+    value
+  end
+end
+
+class ScopedTestClass < ActiveRecord::Base
+  belongs_to :item
+
+  default_scope -> { where(a: 1) }
+end
+
+class Item < ActiveRecord::Base
+  has_many :tags, as: :taggable, dependent: :destroy
+end
+
+class Tag < ActiveRecord::Base
+  belongs_to :taggable, polymorphic: true
+end
+
+describe Hover::Importer::ActiveRecord do
+  let(:record) { TestClass.new }
+  let(:update_finder) { ->(importer, klass, attributes) { record } }
+  let(:remote_local_map) { {table_name: {'remote_id' => 'local_id'}} }
+  let(:importer) { Hover::Importer::ActiveRecord.new(remote_local_map, update_finder) }
+
+  let(:results) do
+    {
+      "state" => "complete",
+      "results" => {
+        "test_classes" => [{"id" => 1}, {"id" => 2}]
+      }
+    }
+  end
+
+  describe "initialize" do
+    it "sets initial values" do
+      importer.remote_local_map.must_equal(remote_local_map)
+      assert_equal importer.update_finder, update_finder
+      importer.column_changes.must_equal({})
+    end
+  end
+
+  describe "update" do
+    it "calls update_record for each" do
+      importer.expects(:update_record).with(TestClass, {"id" => 1}).once
+      importer.expects(:update_record).with(TestClass, {"id" => 2}).once
+
+      importer.update("test_classes", results["results"].delete("test_classes"))
+    end
+
+    it "returns updated records" do
+      importer.expects(:update_record).twice.returns([TestClass, 1])
+      importer.update("test_classes", results["results"].delete("test_classes")).must_equal([[TestClass, 1], [TestClass, 1]])
+    end
+  end
+
+  describe "update_record" do
+    it "does nothing if the record to update is not found" do
+      importer.expects(:find_record_to_update).returns(nil)
+      assert_nil importer.update_record(TestClass, mock)
+    end
+
+    describe "saves" do
+      before do
+      end
+
+      it "does not update primary key and doesnt overwrite s3 keys" do
+        record.expects(:assign_attributes).with({"image_s3_keys" => nil, "document_s3_keys" => nil}).never
+        record.expects(:assign_attributes).with({}).once
+        importer.update_record(TestClass, {"id" => 1})
+      end
+
+      it "handles s3 file attachments" do
+        image_s3_key = {"small" => 100}
+        record.expects(:assign_attributes).with({"image_s3_keys" => image_s3_key}).once
+        importer.update_record(TestClass, {"id" => 1, "image" => image_s3_key})
+      end
+
+      it "excludes invalid column names" do
+        record.expects(:assign_attributes).with({}).once
+        record.expects(:assign_attributes).with({"image_s3_keys" => nil, "document_s3_keys" => nil}).never
+        importer.update_record(TestClass, {"id" => 1, "c" => 2})
+      end
+
+      it "includes valid column names" do
+        record.expects(:assign_attributes).with({"image_s3_keys" => nil, "document_s3_keys" => nil, "a" => 100}).never
+        record.expects(:assign_attributes).with({"a" => 100}).once
+        importer.update_record(TestClass, {"id" => 1, "a" => 100})
+      end
+
+      it "returns record" do
+        record.expects(:assign_attributes).with({"image_s3_keys" => nil, "document_s3_keys" => nil}).never
+        record.expects(:assign_attributes).with({}).once
+        importer.update_record(TestClass, {"id" => 1}).must_equal([TestClass, record.id])
+      end
+    end
+  end
+
+  describe "s3_file_keys" do
+    it "returns nil if klass isn't using s3 file" do
+      assert_nil importer.s3_file_keys(Integer, {})
+    end
+
+    it "skips other attributes" do
+      attributes = {"foo" => 1, 'document' => 2}
+      importer.s3_file_keys(TestClass, attributes).must_equal({'document_s3_keys' => 2})
+    end
+
+    it "does not default to nil" do
+      importer.s3_file_keys(TestClass, {}).must_equal({})
+    end
+
+    it "renames s3 attributes" do
+      attributes = {"image" => 1}
+      importer.s3_file_keys(TestClass, attributes).must_equal({"image_s3_keys" => 1})
+    end
+
+    it "assigns incoming keys correctly" do
+
+      attributes = {
+        "id" => 1,
+        "image" => {
+          "image" => "Midas/Image/236/image.jpg",
+          "image_small" => "Midas/Image/236/image_small.jpg",
+          "image_medium" => "Midas/Image/236/image_medium.jpg",
+          "image_low_quality" => "Midas/Image/236/image_low_quality.jpg",
+          "image_thumb" => "Manowar/Image/172/image_thumb.jpg"
+        }
+      }
+
+      importer.expects(:insert_record).once.with(record).returns(2)
+      TestClass.expects(:new).with({"image_s3_keys" => attributes["image"]}).returns(record)
+
+      importer.import_record(TestClass, attributes).must_equal([TestClass, 2])
+
+      importer.remote_local_map["test_classes"][1].must_equal(2)
+    end
+  end
+
+  describe "find_record_to_update" do
+    it "calls update_finder" do
+      update_finder.expects(:call).with(importer, TestClass, {a: 1})
+      importer.find_record_to_update(TestClass, {a: 1})
+    end
+  end
+
+  describe "import_results" do
+    it "imports" do
+      importer.expects(:import_table).with("test_classes", [{"id" => 1}, {"id" => 2}]).once
+      importer.import_results(results["results"])
+    end
+
+    it "returns [class, id] sets for imported records" do
+      importer.expects(:import_record).returns([record.class, record.id]).twice
+      importer.import_results(results["results"]).must_equal([[TestClass, record.id], [TestClass, record.id]])
+    end
+  end
+
+  describe "import_table" do
+    it "imports" do
+      importer.expects(:import_record).with(TestClass, {"id" => 1}).once
+      importer.import_table("test_classes", [{"id" => 1}])
+    end
+
+    it "returns [class, id] sets for imported records" do
+      importer.expects(:import_record).returns([record.class, record.id]).twice
+      importer.import_table("test_classes", [{}, {}]).must_equal([[TestClass, record.id], [TestClass, record.id]])
+    end
+  end
+
+  describe "import_record" do
+    it "returns nil if insert fails" do
+      importer.expects(:insert_record).once.returns(nil)
+      TestClass.expects(:find).never
+      assert_nil importer.import_record(TestClass, {})
+    end
+
+    it "imports" do
+      importer.expects(:insert_record).once.with(record).returns(2)
+      TestClass.expects(:new).with({}).returns(record)
+
+      importer.import_record(TestClass, {"id" => 1}).must_equal([TestClass, 2])
+
+      importer.remote_local_map["test_classes"][1].must_equal(2)
+    end
+
+    it "filters out attributes that don't have corresponding columns in the local database" do
+      class TestClass
+        def attributes
+          super.merge('upstream_attribute' => 1)
+        end
+      end
+
+      starting_count = TestClass.count
+      importer.import_record(TestClass, {})
+      assert_equal (starting_count + 1), TestClass.count
+    end
+  end
+
+  describe "insert_record" do
+    it "inserts" do
+      TestClass.expects(:_insert_record).returns(1)
+
+      attributes = {"id" => 33}
+      record = TestClass.new(attributes)
+
+      importer.insert_record(record).must_equal(1)
+    end
+
+
+  end
+
+  describe "new_foreign_keys" do
+    it do
+      record.item_id = 2
+      importer.remote_local_map["items"] = {2 => 1}
+
+      importer.new_foreign_keys(record).must_equal({"item_id" => 1})
+    end
+
+    it "processes belongs_to macro" do
+      record.item_id = 2
+      association = record.class.reflect_on_all_associations.first
+      importer.expects(:new_foreign_keys_for_belongs_to).with(record, association)
+      importer.new_foreign_keys(record)
+    end
+
+    it "processes polymorphic belongs_to macro" do
+      tag = Tag.create!(name: 'tag', taggable_type: Item.name, taggable_id: 1)
+      association = tag.class.reflect_on_all_associations.first
+      importer.expects(:new_foreign_keys_for_belongs_to_polymorphic).with(tag, association)
+      importer.new_foreign_keys(tag)
+    end
+
+    it "supports polymorphic relationships" do
+      tag = Tag.create!(name: 'tag', taggable_type: Item.name, taggable_id: 1)
+      importer.remote_local_map["items"] = {1 => 3}
+      importer.new_foreign_keys(tag).must_equal({"taggable_id" => 3})
+    end
+  end
+
+  describe "new_foreign_keys_belongs_to" do
+    it do
+      record.item_id = 2
+      importer.remote_local_map["items"] = {2 => 1}
+      association = record.class.reflect_on_all_associations.first
+
+      importer.new_foreign_keys_for_belongs_to(record, association).must_equal(['item_id', 1])
+    end
+  end
+
+  describe "new_foreign_keys_belongs_to_polymorphic" do
+    it do
+      tag = Tag.create!(name: 'tag', taggable_type: Item.name, taggable_id: 1)
+      association = tag.class.reflect_on_all_associations.first
+      importer.remote_local_map["items"] = {1 => 3}
+      importer.new_foreign_keys_for_belongs_to_polymorphic(tag, association).must_equal(["taggable_id", 3])
+    end
+  end
+
+  describe "update_foreign_keys" do
+    it "does nothing with no new foreign keys" do
+      assert_nil importer.update_foreign_keys(Item.new)
+    end
+
+    it "updates foreign keys" do
+      record.item_id = 2
+      importer.remote_local_map["items"] = {2 => 1}
+
+      TestClass.const_get(:ActiveRecord_Relation).any_instance.expects(:update_all).once.with({'item_id' => 1})
+      record.expects(:reload).returns(record)
+
+      importer.update_foreign_keys(record).must_equal([TestClass, record.id])
+    end
+
+    it "updates foreign keys db" do
+      record.item_id = 2
+      record.save!
+
+      importer.remote_local_map["items"] = {2 => 1}
+
+      importer.update_foreign_keys(record).must_equal([TestClass, record.id])
+
+      record.reload
+      assert_equal 1, record.item_id
+    end
+
+    it "skips default scopes" do
+      item_id = 2
+      a = 4
+      scoped_record = ScopedTestClass.create!(a: a, item_id: item_id)
+
+      importer.remote_local_map["items"] = {2 => 1}
+
+      importer.update_foreign_keys(scoped_record)
+
+      scoped_record.reload
+      assert_equal 1, scoped_record.item_id
+    end
+
+    it "updates polymorphic foreign keys" do
+      tag = Tag.create!(name: 'tag', taggable_type: Item.name, taggable_id: 2)
+      importer.remote_local_map["items"] = {2 => 1}
+
+      Tag.const_get(:ActiveRecord_Relation).any_instance.expects(:update_all).once.with({'taggable_id' => 1})
+      tag.expects(:reload).returns(tag)
+
+      importer.update_foreign_keys(tag).must_equal([Tag, tag.id])
+    end
+  end
+
+  describe "column_changes" do
+    describe "change_columns" do
+      it "changes" do
+        importer.column_changes = {"building_version_id" => "model_id"}
+        importer.change_columns({"building_version_id" => 2}).must_equal({"model_id" => 2})
+      end
+
+      it "doesn't affect other columns" do
+        importer.column_changes = {"a" => "b"}
+        importer.change_columns({"c" => 2}).must_equal({"c" => 2})
+      end
+    end
+
+    it "change during update" do
+      importer.column_changes["building_version_id"] = "item_id"
+      record.expects(:save!)
+      importer.update(TestClass.table_name, [{"building_version_id" => 2, "id" => 1}]).must_equal([[record.class, record.id]])
+      record.item_id.must_equal(2)
+    end
+
+    it "change during insert" do
+      importer.column_changes["building_version_id"] = "item_id"
+      importer.expects(:import_record).with(TestClass, {"item_id" => 2, "id" => 1}).once.returns([TestClass, record.id])
+      importer.import_table(TestClass.table_name, [{"item_id" => 2, "id" => 1}]).must_equal([[TestClass, record.id]])
+    end
+  end
+end