rets-hack 0.11

data/test/test_metadata.rb

@@ -0,0 +1,71 @@
+require_relative "helper"
+
+class TestMetadata < MiniTest::Test
+  def test_metadata_uses
+    #TODO
+  end
+
+  def test_print_tree
+    hoa_lookup_types = [
+      Rets::Metadata::LookupType.new("LongValue" => "Quarterly", "Value" => "Q"),
+      Rets::Metadata::LookupType.new("LongValue" => "Annually", "Value" => "A"),
+    ]
+
+    table_fragment = {
+      "Units" => "Meters",
+      "Searchable" => "Y",
+      'Required' => "N",
+
+      "SystemName" => "L_1",
+      "ShortName" => "Sq",
+      "LongName" => "Square Footage",
+      "StandardName" => "Sqft",
+    }
+
+    lookup_table_fragment = {
+      "Required" => "N",
+      "Searchable" => "Y",
+      "Units" => "",
+      "Interpretation" => "N",
+
+      "SystemName" => "L_10",
+      "ShortName" => "HF",
+      "LongName" => "HOA Frequency",
+      "StandardName" => "HOA F",
+    }
+
+    multi_lookup_table_fragment = {
+      "Required" => "N",
+      "Searchable" => "Y",
+      "Units" => "",
+      "Interpretation" => "N",
+
+      "SystemName" => "L_11",
+      "ShortName" => "HFs",
+      "LongName" => "HOA Frequencies",
+      "StandardName" => "HOA Fs",
+    }
+
+    resource_id = "Properties"
+    tables = [
+      Rets::Metadata::Table.new(table_fragment, resource_id),
+      Rets::Metadata::LookupTable.new(resource_id, hoa_lookup_types, lookup_table_fragment),
+      Rets::Metadata::MultiLookupTable.new(resource_id, hoa_lookup_types, multi_lookup_table_fragment),
+    ]
+
+    rets_classes = [
+      Rets::Metadata::RetsClass.new("T100", "Prop", "standard name", "some description", tables)
+    ]
+
+    rets_objects = [
+      Rets::Metadata::RetsObject.new("HiRes", "Photo", "photo/jpg", "photo description")
+    ]
+
+    resource = Rets::Metadata::Resource.new(resource_id, "matrix_unique_key", rets_classes, rets_objects)
+
+    io = StringIO.new
+    resource.print_tree(io)
+
+    assert_equal io.string, EXAMPLE_METADATA_TREE
+  end
+end

data/test/test_metadata_class.rb

@@ -0,0 +1,50 @@
+require_relative "helper"
+
+class TestMetadataClass < MiniTest::Test
+  def test_rets_class_find_table
+    table = Rets::Metadata::Table.new({ "SystemName" => 'test' }, 'resource_id')
+    rets_class = Rets::Metadata::RetsClass.new('class_name', 'visible_name', 'standard name', 'description', [table])
+
+    assert_equal table, rets_class.find_table("test")
+  end
+
+  def test_rets_class_find_lookup_table
+    table = Rets::Metadata::LookupTable.new('resource_id', [], { "SystemName" => 'test' })
+    rets_class = Rets::Metadata::RetsClass.new('class_name', 'visible_name', 'standard name', 'description', [table])
+
+    assert_equal table, rets_class.find_table("test")
+  end
+
+  def test_rets_class_find_table_container
+    resource_id = "a"
+    class_name = "b"
+
+    table = mock(:resource => resource_id, :class => class_name)
+    metadata = { :table => [table] }
+
+    assert_equal table, Rets::Metadata::RetsClass.find_table_container(metadata, resource_id, class_name)
+  end
+
+  def test_rets_class_build
+    resource_id = "id"
+    lookup_types = []
+
+    table_fragment = stub(:fragment)
+    table_container = stub(:tables => [table_fragment])
+    table = stub(:table)
+
+    Rets::Metadata::TableFactory.expects(:build).with(table_fragment, resource_id, lookup_types).returns(table)
+    Rets::Metadata::RetsClass.expects(:find_table_container).returns(table_container)
+
+    rets_class = Rets::Metadata::RetsClass.build({}, resource_id, lookup_types, "")
+
+    assert_equal(rets_class.tables, [table])
+  end
+
+  def test_rets_class_build_when_find_table_container_returns_nil
+    new_rets_class = stub(:new_rets_class)
+    Rets::Metadata::RetsClass.stubs(:new => new_rets_class)
+    Rets::Metadata::RetsClass.stubs(:find_table_container => nil)
+    Rets::Metadata::RetsClass.build({}, "resource_id", [], "")
+  end
+end

data/test/test_metadata_lookup_table.rb

@@ -0,0 +1,21 @@
+require_relative "helper"
+
+class TestMetadataLookupTable < MiniTest::Test
+  def setup
+    $VERBOSE = true
+  end
+
+  def teardown
+    $VERBOSE = false
+  end
+
+  def test_lookup_table_resolve_returns_single_value_if_not_multi
+    fragment = {}
+    lookup_types = [
+      Rets::Metadata::LookupType.new("Value" => "A,B", "LongValue" => "AaaBbb")
+    ]
+    lookup_table = Rets::Metadata::LookupTable.new("Foo", lookup_types, fragment)
+
+    assert_equal "AaaBbb", lookup_table.resolve("A,B")
+  end
+end

data/test/test_metadata_lookup_type.rb

@@ -0,0 +1,21 @@
+require_relative "helper"
+
+class TestMetadataLookupType < MiniTest::Test
+  def test_lookup_type_initialize
+    fragment = { "Value" => 'a', "LongValue" => 'c' }
+
+    lookup_type = Rets::Metadata::LookupType.new(fragment)
+
+    assert_equal('a', lookup_type.value)
+    assert_equal('c', lookup_type.long_value)
+  end
+
+  def test_lookup_type_ignores_trailing_whitespace
+    fragment = { "Value" => 'a     ', "LongValue" => 'c     ' }
+
+    lookup_type = Rets::Metadata::LookupType.new(fragment)
+
+    assert_equal('a', lookup_type.value)
+    assert_equal('c', lookup_type.long_value)
+  end
+end

data/test/test_metadata_multi_lookup_table.rb

@@ -0,0 +1,60 @@
+require_relative "helper"
+
+class TestMetadataMultiLookupTable < MiniTest::Test
+  def setup
+    @fragment = { "Interpretation" => "LookupMulti" }
+    $VERBOSE = true
+  end
+
+  def teardown
+    $VERBOSE = false
+  end
+
+  def test_lookup_table_resolve_returns_empty_array_when_value_is_empty_and_is_multi?
+    lookup_table = Rets::Metadata::MultiLookupTable.new("Foo", [], @fragment)
+
+    assert_equal [], lookup_table.resolve("")
+  end
+
+  def test_lookup_table_resolve_returns_multi_value_array_when_multi
+    lookup_types = [
+      Rets::Metadata::LookupType.new("Value" => "A", "LongValue" => "Aaa"),
+      Rets::Metadata::LookupType.new("Value" => "B", "LongValue" => "Bbb"),
+    ]
+    lookup_table = Rets::Metadata::MultiLookupTable.new("Foo", lookup_types, @fragment)
+
+    assert_equal ["Aaa", "Bbb"], lookup_table.resolve("A,B")
+  end
+
+  #Sandicor does this :|
+  def test_lookup_table_resolve_returns_multi_value_array_when_multi_with_quoted_values
+    lookup_types = [
+      Rets::Metadata::LookupType.new("Value" => "A", "LongValue" => "Aaa"),
+      Rets::Metadata::LookupType.new("Value" => "B", "LongValue" => "Bbb"),
+    ]
+    lookup_table = Rets::Metadata::MultiLookupTable.new("Foo", lookup_types, @fragment)
+
+    assert_equal ["Aaa", "Bbb"], lookup_table.resolve(%q["A","B"])
+  end
+
+  # This scenario is unfortunately common.
+  def test_lookup_table_resolve_returns_nil_when_lookup_type_is_not_present_for_multi_value
+    lookup_types = [
+      Rets::Metadata::LookupType.new("Value" => "A", "LongValue" => "Aaa"),
+    ]
+    lookup_table = Rets::Metadata::MultiLookupTable.new("Foo", lookup_types, @fragment)
+
+    lookup_table.expects(:warn).with("Discarding unmappable value of #{"B".inspect}")
+
+    assert_equal ["Aaa", ""], lookup_table.resolve("A,B")
+  end
+
+  # This scenario is unfortunately common.
+  def test_lookup_table_resolve_returns_nil_when_lookup_type_is_not_present_for_single_value
+    lookup_table = Rets::Metadata::MultiLookupTable.new("Foo", [], @fragment)
+
+    lookup_table.expects(:warn).with("Discarding unmappable value of #{"A".inspect}")
+
+    assert_equal [""], lookup_table.resolve("A")
+  end
+end

data/test/test_metadata_object.rb

@@ -0,0 +1,33 @@
+require_relative "helper"
+
+class TestMetadataObject < MiniTest::Test
+  def test_rets_object_build
+    name = "Name"
+    mime_type = "mimetype"
+    description = "description"
+    object_type = "type"
+
+    object_fragment = {
+      "ObjectType" => object_type,
+      "VisibleName" => name,
+      "MIMEType"    => mime_type,
+      "Description" => description,
+    }
+
+    assert_equal(
+      Rets::Metadata::RetsObject.build(object_fragment),
+      Rets::Metadata::RetsObject.new(object_type, name, mime_type, description)
+    )
+  end
+
+  def test_rets_object_building_not_case_dependent
+    object_fragment = {
+      "MiMeTyPe" => "image/jpeg"
+    }
+
+    assert_equal(
+      Rets::Metadata::RetsObject.build(object_fragment).mime_type,
+      "image/jpeg"
+    )
+  end
+end

data/test/test_metadata_resource.rb

@@ -0,0 +1,148 @@
+require_relative "helper"
+
+class TestMetadataResource < MiniTest::Test
+  def test_resource_build_lookup_tree
+    metadata = stub(:metadata)
+    resource = stub(:resource)
+
+    Rets::Metadata::Resource.expects(:find_lookup_containers).
+      with(metadata, resource).
+      returns([stub(:lookups => [{"LookupName" => "Foo"}])])
+
+    Rets::Metadata::Resource.expects(:find_lookup_type_containers).
+      with(metadata, resource, "Foo").
+      returns([stub(:lookup_types => [{"Value" => "111", "LongValue" => "Bar"}])])
+
+    tree = Rets::Metadata::Resource.build_lookup_tree(resource, metadata)
+
+    assert_equal ["Foo"], tree.keys
+    assert_equal 1, tree["Foo"].size
+
+    lookup_type = tree["Foo"].first
+
+    assert_equal "111", lookup_type.value
+    assert_equal "Bar", lookup_type.long_value
+  end
+
+  def test_resource_build_classes
+    resource_id = "id"
+    lookup_types = []
+
+    metadata = stub(:metadata)
+    rets_class = stub(:rets_class)
+    rets_class_fragment = stub(:rets_class_fragment)
+
+    Rets::Metadata::RetsClass.expects(:build).with(rets_class_fragment, resource_id, lookup_types, metadata).returns(rets_class)
+    Rets::Metadata::Resource.expects(:find_rets_classes).with(metadata, resource_id).returns([rets_class_fragment])
+
+    classes = Rets::Metadata::Resource.build_classes(resource_id, lookup_types, metadata)
+    assert_equal([rets_class], classes)
+  end
+
+  def test_resource_build_objects
+    resource_id = "id"
+
+    metadata = stub(:metadata)
+    rets_object = stub(:rets_object)
+    rets_object_fragment = stub(:rets_object_fragment)
+
+    Rets::Metadata::RetsObject.expects(:build).with(rets_object_fragment).returns(rets_object)
+    Rets::Metadata::Resource.expects(:find_rets_objects).with(metadata, resource_id).returns([rets_object_fragment])
+
+    objects = Rets::Metadata::Resource.build_objects(resource_id, metadata)
+    assert_equal([rets_object], objects)
+  end
+
+  def test_resource_build_objects_when_objects_were_not_loaded
+    resource_id = "id"
+    metadata    = {} # doesn't contain metadata for :object key
+
+    objects = Rets::Metadata::Resource.build_objects(resource_id, metadata)
+    assert_equal [], objects
+  end
+
+  def test_resource_build
+    fragment = { "ResourceID" => "test" }
+
+    lookup_types = stub(:lookup_types)
+    classes = stub(:classes)
+    objects = stub(:objects)
+    metadata = stub(:metadata)
+
+    Rets::Metadata::Resource.stubs(:build_lookup_tree => lookup_types)
+    Rets::Metadata::Resource.stubs(:build_classes => classes)
+    Rets::Metadata::Resource.stubs(:build_objects => objects)
+
+    resource = Rets::Metadata::Resource.build(fragment, metadata, Logger.new(STDOUT))
+
+    assert_equal(classes, resource.rets_classes)
+    assert_equal(objects, resource.rets_objects)
+  end
+
+  def test_resource_build_with_incomplete_classes
+    fragment = { "ResourceID" => "test" }
+
+    lookup_types = stub(:lookup_types)
+    metadata = stub(:metadata)
+
+    Rets::Metadata::Resource.stubs(:build_lookup_tree => lookup_types)
+    Rets::Metadata::Resource.stubs(:build_classes).raises(Rets::Metadata::Resource::MissingRetsClass)
+
+    error_log = StringIO.new
+    resource = Rets::Metadata::Resource.build(fragment, metadata, Logger.new(error_log))
+
+    error_log.rewind
+    error_msg = error_log.read
+    assert error_msg.include?('MissingRetsClass')
+    assert_equal(nil, resource)
+  end
+
+  def test_resource_find_lookup_containers
+    resource_id = "id"
+    metadata = {
+      :lookup => [
+        stub(:resource => resource_id),
+        stub(:resource => resource_id),
+        stub(:resource => "a")
+      ]
+    }
+
+    lookup_containers = Rets::Metadata::Resource.find_lookup_containers(metadata, resource_id)
+
+    assert_equal(2, lookup_containers.size)
+    assert_equal(["id", "id"], lookup_containers.map(&:resource))
+  end
+
+  def test_resource_find_lookup_type_containers
+    resource_id = "id"
+    metadata = {
+      :lookup_type => [
+        stub(:resource => resource_id, :lookup => "look"),
+        stub(:resource => resource_id, :lookup => "look"),
+        stub(:resource => resource_id, :lookup => "not_look"),
+        stub(:resource => "a",         :lookup => "look"),
+        stub(:resource => "a",         :lookup => "not_look")
+      ]
+    }
+    lookup_type_containers = Rets::Metadata::Resource.find_lookup_type_containers(metadata, resource_id, "look")
+
+    assert_equal(2, lookup_type_containers.size)
+    assert_equal(["id", "id"], lookup_type_containers.map(&:resource))
+  end
+
+  def test_resource_find_rets_classes
+    rets_classes = stub(:rets_classes)
+
+    metadata = { :class => [stub(:resource => "id", :classes => rets_classes),
+                            stub(:resource => "id", :classes => rets_classes),
+                            stub(:resource => "a")]}
+
+    assert_equal(rets_classes, Rets::Metadata::Resource.find_rets_classes(metadata, "id"))
+  end
+
+  def test_resource_find_rets_class
+    rets_class = Rets::Metadata::RetsClass.new('test', '', '', '', [])
+    resource = Rets::Metadata::Resource.new('', '', [rets_class], [])
+    assert_equal(rets_class, resource.find_rets_class("test"))
+  end
+end

data/test/test_metadata_root.rb

@@ -0,0 +1,151 @@
+require_relative "helper"
+
+class TestMetadataRoot < MiniTest::Test
+  def setup
+    @root = Rets::Metadata::Root.new(Logger.new(STDOUT), {})
+  end
+
+  def test_metadata_root_build_tree
+    resource = stub(:id => "X")
+    Rets::Metadata::Resource.stubs(:build => resource)
+    resource_fragment = stub(:resource_fragment)
+    resource_container = stub(:rows => [resource_fragment])
+    @root.stubs(:metadata_types => { :resource => [resource_container] })
+    assert_equal({"x" => resource}, @root.build_tree)
+    assert_equal(resource, @root.build_tree["X"])
+  end
+
+  def test_metadata_root_version
+    @root.instance_variable_set("@metadata_types", {:system => [stub(:version => "1")]})
+    assert_equal "1", @root.version
+  end
+
+  def test_metadata_root_date
+    @root.instance_variable_set("@metadata_types", {:system => [stub(:date => "1")]})
+    assert_equal "1", @root.date
+  end
+
+  def test_metadata_root_different_version
+    @root.stubs(:version).returns("1.2.2")
+    @root.stubs(:date).returns("1")
+
+    current_version = "1.2.3"
+    current_timestamp = "1"
+
+    assert !@root.current?(current_timestamp, current_version)
+  end
+
+  def test_metadata_root_same_version
+    @root.stubs(:version).returns("1.2.2")
+    @root.stubs(:date).returns("1")
+
+    current_version = "1.2.2"
+    current_timestamp = "2"
+
+    assert @root.current?(current_timestamp, current_version)
+  end
+
+  def test_metadata_root_no_version_same_timestamp
+    @root.stubs(:version).returns("")
+    @root.stubs(:date).returns("1")
+
+    current_version = "1.2.3"
+    current_timestamp = "1"
+
+    assert @root.current?(current_timestamp, current_version)
+  end
+
+  def test_metadata_root_current
+    @root.stubs(:version).returns("1.2.2")
+    @root.stubs(:date).returns("1")
+
+    current_timestamp = "1"
+    current_version = "1.2.2"
+
+    assert @root.current?(current_timestamp, current_version)
+  end
+
+  # missing timestamp - this happens in violation of the spec.
+  def test_metadata_root_current_ignores_missing_timestamp
+    @root.stubs(:version).returns("1.2.2")
+    @root.stubs(:date).returns("1")
+
+    current_timestamp = nil
+    current_version = "1.2.2"
+
+    assert @root.current?(current_timestamp, current_version)
+  end
+
+  # missing version - this happens in violation of the spec.
+  def test_metadata_root_current_ignores_missing_version
+    @root.stubs(:version).returns("1.2.2")
+    @root.stubs(:date).returns("1")
+
+    current_timestamp = "1"
+    current_version = nil
+
+    assert @root.current?(current_timestamp, current_version)
+  end
+
+  def test_metadata_root_metadata_types_constructs_a_hash_of_metadata_types_from_sources
+    test_sources = { "X" => "Y", "Z" => "W" }
+    root = Rets::Metadata::Root.new(stub(:logger), test_sources)
+    root.stubs(:build_containers => "Y--")
+    Nokogiri.stubs(:parse => "Y-")
+
+    assert_equal({:x => "Y--", :z => "Y--"}, root.metadata_types)
+  end
+
+  def test_metadata_root_build_containers_selects_correct_tags
+    doc = "<RETS><METADATA-FOO></METADATA-FOO><MET-FOO></MET-FOO><METADATA-BAR /></RETS>"
+
+    @root.expects(:build_container).with { |fragment| fragment.name == "METADATA-FOO" }
+    @root.expects(:build_container).with { |fragment| fragment.name == "METADATA-BAR" }
+
+    @root.build_containers(Nokogiri.parse(doc))
+  end
+
+  def test_metadata_root_build_container_uses_row_containers_for_resource
+    doc = Nokogiri.parse(METADATA_RESOURCE).xpath("//METADATA-RESOURCE").first
+
+    container = @root.build_container(doc)
+
+    assert_instance_of Rets::Metadata::Containers::ResourceContainer, container
+
+    assert_equal 13, container.resources.size
+
+    resource = container.resources.first
+
+    assert_equal "ActiveAgent", resource["StandardName"]
+  end
+
+  def test_metadata_root_build_container_uses_system_container_for_system
+    doc = Nokogiri.parse(METADATA_SYSTEM).xpath("//METADATA-SYSTEM").first
+
+    container = @root.build_container(doc)
+    assert_instance_of Rets::Metadata::Containers::SystemContainer, container
+  end
+
+  def test_metadata_root_build_container_uses_base_container_for_unknown_metadata_types
+    doc = Nokogiri.parse(METADATA_UNKNOWN).xpath("//METADATA-FOO").first
+
+    container = @root.build_container(doc)
+    assert_instance_of Rets::Metadata::Containers::Container, container
+  end
+
+  def test_root_can_be_serialized
+    sources = { :x => "a" }
+    root = Rets::Metadata::Root.new(stub(:logger), sources)
+    assert_equal sources, root.marshal_dump
+  end
+
+  def test_root_can_be_unserialized
+    logger = stub(:logger)
+    sources = { :x => "a" }
+
+    root_to_serialize = Rets::Metadata::Root.new(logger, sources)
+    new_root = Rets::Metadata::Root.new(logger, root_to_serialize.marshal_dump)
+
+    assert_equal root_to_serialize.marshal_dump, new_root.marshal_dump
+  end
+end

data/test/test_metadata_table.rb

@@ -0,0 +1,21 @@
+require_relative "helper"
+
+class TestMetadataTable < MiniTest::Test
+  def test_table_resolve_returns_empty_string_when_value_nil
+    table = Rets::Metadata::Table.new({}, "resource_id")
+
+    assert_equal "", table.resolve(nil)
+  end
+
+  def test_table_resolve_passes_values_straight_through
+    table = Rets::Metadata::Table.new({}, "resource_id")
+
+    assert_equal "Foo", table.resolve("Foo")
+  end
+
+  def test_table_resolve_passes_values_strips_extra_whitspace
+    table = Rets::Metadata::Table.new({}, "resource_id")
+
+    assert_equal "Foo", table.resolve(" Foo ")
+  end
+end

data/test/test_metadata_table_factory.rb

@@ -0,0 +1,24 @@
+require_relative "helper"
+
+class TestMetadataTableFactory < MiniTest::Test
+  def test_table_factory_creates_mutli_lookup_table
+    table_fragment = {"LookupName" => "Foo", "Interpretation" => "LookupMulti"}
+    resource_id = "id"
+    lookup_types = {}
+    assert_instance_of Rets::Metadata::MultiLookupTable, Rets::Metadata::TableFactory.build(table_fragment, resource_id, lookup_types)
+  end
+
+  def test_table_factory_creates_lookup_table
+    table_fragment = {"LookupName" => "Foo", "Interpretation" => "Lookup"}
+    resource_id = "id"
+    lookup_types = {}
+    assert_instance_of Rets::Metadata::LookupTable, Rets::Metadata::TableFactory.build(table_fragment, resource_id, lookup_types)
+  end
+
+  def test_table_factory_creates_table
+    table_fragment = {"LookupName" => "", "Interpretation" => ""}
+    resource_id = "id"
+    lookup_types = {}
+    assert_instance_of Rets::Metadata::Table, Rets::Metadata::TableFactory.build(table_fragment, resource_id, lookup_types)
+  end
+end