avro-salsify-fork 1.9.0.0

data/test/test_logical_types.rb

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_help'
+
+class TestLogicalTypes < Test::Unit::TestCase
+  def test_int_date
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "int", "logicalType": "date" }
+    SCHEMA
+
+    assert_equal 'date', schema.logical_type
+    assert_encode_and_decode Date.today, schema
+  end
+
+  def test_int_date_conversion
+    type = Avro::LogicalTypes::IntDate
+
+    assert_equal 5, type.encode(Date.new(1970, 1, 6))
+    assert_equal 0, type.encode(Date.new(1970, 1, 1))
+    assert_equal -5, type.encode(Date.new(1969, 12, 27))
+
+    assert_equal Date.new(1970, 1, 6), type.decode(5)
+    assert_equal Date.new(1970, 1, 1), type.decode(0)
+    assert_equal Date.new(1969, 12, 27), type.decode(-5)
+  end
+
+  def test_timestamp_millis_long
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "long", "logicalType": "timestamp-millis" }
+    SCHEMA
+
+    # The Time.at format is (seconds, microseconds) since Epoch.
+    datum = Time.at(628232400, 12000)
+
+    assert_equal 'timestamp-millis', schema.logical_type
+    assert_encode_and_decode datum, schema
+  end
+
+  def test_timestamp_millis_long_conversion
+    type = Avro::LogicalTypes::TimestampMillis
+
+    now = Time.now.utc
+    now_millis = Time.utc(now.year, now.month, now.day, now.hour, now.min, now.sec, now.usec / 1000 * 1000)
+
+    assert_equal now_millis, type.decode(type.encode(now_millis))
+    assert_equal 1432849613221, type.encode(Time.utc(2015, 5, 28, 21, 46, 53, 221000))
+    assert_equal 1432849613221, type.encode(DateTime.new(2015, 5, 28, 21, 46, 53.221))
+    assert_equal Time.utc(2015, 5, 28, 21, 46, 53, 221000), type.decode(1432849613221)
+  end
+
+  def test_timestamp_micros_long
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "long", "logicalType": "timestamp-micros" }
+    SCHEMA
+
+    # The Time.at format is (seconds, microseconds) since Epoch.
+    datum = Time.at(628232400, 12345)
+
+    assert_equal 'timestamp-micros', schema.logical_type
+    assert_encode_and_decode datum, schema
+  end
+
+  def test_timestamp_micros_long_conversion
+    type = Avro::LogicalTypes::TimestampMicros
+
+    now = Time.now.utc
+
+    assert_equal now, type.decode(type.encode(now))
+    assert_equal 1432849613221843, type.encode(Time.utc(2015, 5, 28, 21, 46, 53, 221843))
+    assert_equal 1432849613221843, type.encode(DateTime.new(2015, 5, 28, 21, 46, 53.221843))
+    assert_equal Time.utc(2015, 5, 28, 21, 46, 53, 221843), type.decode(1432849613221843)
+  end
+
+  def encode(datum, schema)
+    buffer = StringIO.new("")
+    encoder = Avro::IO::BinaryEncoder.new(buffer)
+
+    datum_writer = Avro::IO::DatumWriter.new(schema)
+    datum_writer.write(datum, encoder)
+
+    buffer.string
+  end
+
+  def decode(encoded, schema)
+    buffer = StringIO.new(encoded)
+    decoder = Avro::IO::BinaryDecoder.new(buffer)
+
+    datum_reader = Avro::IO::DatumReader.new(schema, schema)
+    datum_reader.read(decoder)
+  end
+
+  def assert_encode_and_decode(datum, schema)
+    encoded = encode(datum, schema)
+    assert_equal datum, decode(encoded, schema)
+  end
+end

data/test/test_protocol.rb

@@ -0,0 +1,199 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_help'
+
+class TestProtocol < Test::Unit::TestCase
+
+  class ExampleProtocol
+    attr_reader :protocol_string, :valid, :name
+    attr_accessor :comment
+    def initialize(protocol_string, name=nil, comment='')
+      @protocol_string = protocol_string
+      @name = name || protocol_string # default to schema_string for name
+      @comment = comment
+    end
+  end
+#
+# Example Protocols
+#
+
+EXAMPLES = [
+  ExampleProtocol.new(<<-EOS, true),
+{
+  "namespace": "com.acme",
+  "protocol": "HelloWorld",
+
+  "types": [
+    {"name": "Greeting", "type": "record", "fields": [
+      {"name": "message", "type": "string"}]},
+    {"name": "Curse", "type": "error", "fields": [
+      {"name": "message", "type": "string"}]}
+  ],
+
+  "messages": {
+    "hello": {
+      "request": [{"name": "greeting", "type": "Greeting" }],
+      "response": "Greeting",
+      "errors": ["Curse"]
+    }
+  }
+}
+EOS
+
+  ExampleProtocol.new(<<-EOS, true),
+{"namespace": "org.apache.avro.test",
+ "protocol": "Simple",
+
+ "types": [
+     {"name": "Kind", "type": "enum", "symbols": ["FOO","BAR","BAZ"]},
+
+     {"name": "MD5", "type": "fixed", "size": 16},
+
+     {"name": "TestRecord", "type": "record",
+      "fields": [
+          {"name": "name", "type": "string", "order": "ignore"},
+          {"name": "kind", "type": "Kind", "order": "descending"},
+          {"name": "hash", "type": "MD5"}
+      ]
+     },
+
+     {"name": "TestError", "type": "error", "fields": [
+         {"name": "message", "type": "string"}
+      ]
+     }
+
+ ],
+
+ "messages": {
+
+     "hello": {
+         "request": [{"name": "greeting", "type": "string"}],
+         "response": "string"
+     },
+
+     "echo": {
+         "request": [{"name": "record", "type": "TestRecord"}],
+         "response": "TestRecord"
+     },
+
+     "add": {
+         "request": [{"name": "arg1", "type": "int"}, {"name": "arg2", "type": "int"}],
+         "response": "int"
+     },
+
+     "echoBytes": {
+         "request": [{"name": "data", "type": "bytes"}],
+         "response": "bytes"
+     },
+
+     "error": {
+         "request": [],
+         "response": "null",
+         "errors": ["TestError"]
+     }
+ }
+
+}
+EOS
+  ExampleProtocol.new(<<-EOS, true),
+{"namespace": "org.apache.avro.test.namespace",
+ "protocol": "TestNamespace",
+
+ "types": [
+     {"name": "org.apache.avro.test.util.MD5", "type": "fixed", "size": 16},
+     {"name": "TestRecord", "type": "record",
+      "fields": [ {"name": "hash", "type": "org.apache.avro.test.util.MD5"} ]
+     },
+     {"name": "TestError", "namespace": "org.apache.avro.test.errors",
+      "type": "error", "fields": [ {"name": "message", "type": "string"} ]
+     }
+ ],
+
+ "messages": {
+     "echo": {
+         "request": [{"name": "record", "type": "TestRecord"}],
+         "response": "TestRecord"
+     },
+
+     "error": {
+         "request": [],
+         "response": "null",
+         "errors": ["org.apache.avro.test.errors.TestError"]
+     }
+
+ }
+
+}
+EOS
+  ExampleProtocol.new(<<-EOS, true)
+{"namespace": "org.apache.avro.test",
+ "protocol": "BulkData",
+
+ "types": [],
+
+ "messages": {
+
+     "read": {
+         "request": [],
+         "response": "bytes"
+     },
+
+     "write": {
+         "request": [ {"name": "data", "type": "bytes"} ],
+         "response": "null"
+     }
+
+ }
+
+}
+EOS
+]
+
+  Protocol = Avro::Protocol
+  def test_parse
+    EXAMPLES.each do |example|
+      assert_nothing_raised("should be valid: #{example.protocol_string}") {
+        Protocol.parse(example.protocol_string)
+      }
+    end
+  end
+
+  def test_valid_cast_to_string_after_parse
+    EXAMPLES.each do |example|
+      assert_nothing_raised("round tripped okay #{example.protocol_string}") {
+        foo = Protocol.parse(example.protocol_string).to_s
+        Protocol.parse(foo)
+      }
+    end
+  end
+
+  def test_equivalence_after_round_trip
+    EXAMPLES.each do |example|
+      original = Protocol.parse(example.protocol_string)
+      round_trip = Protocol.parse(original.to_s)
+
+      assert_equal original, round_trip
+    end
+  end
+
+  def test_namespaces
+    protocol = Protocol.parse(EXAMPLES.first.protocol_string)
+    protocol.types.each do |type|
+      assert_equal type.namespace, 'com.acme'
+    end
+  end
+end

data/test/test_schema.rb

@@ -0,0 +1,146 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_help'
+
+class TestSchema < Test::Unit::TestCase
+  def test_default_namespace
+    schema = Avro::Schema.parse <<-SCHEMA
+      {"type": "record", "name": "OuterRecord", "fields": [
+        {"name": "field1", "type": {
+          "type": "record", "name": "InnerRecord", "fields": []
+        }},
+        {"name": "field2", "type": "InnerRecord"}
+      ]}
+    SCHEMA
+
+    assert_equal schema.name, 'OuterRecord'
+    assert_equal schema.fullname, 'OuterRecord'
+    assert_nil schema.namespace
+
+    schema.fields.each do |field|
+      assert_equal field.type.name, 'InnerRecord'
+      assert_equal field.type.fullname, 'InnerRecord'
+      assert_nil field.type.namespace
+    end
+  end
+
+  def test_inherited_namespace
+    schema = Avro::Schema.parse <<-SCHEMA
+      {"type": "record", "name": "OuterRecord", "namespace": "my.name.space",
+       "fields": [
+          {"name": "definition", "type": {
+            "type": "record", "name": "InnerRecord", "fields": []
+          }},
+          {"name": "relativeReference", "type": "InnerRecord"},
+          {"name": "absoluteReference", "type": "my.name.space.InnerRecord"}
+      ]}
+    SCHEMA
+
+    assert_equal schema.name, 'OuterRecord'
+    assert_equal schema.fullname, 'my.name.space.OuterRecord'
+    assert_equal schema.namespace, 'my.name.space'
+    schema.fields.each do |field|
+      assert_equal field.type.name, 'InnerRecord'
+      assert_equal field.type.fullname, 'my.name.space.InnerRecord'
+      assert_equal field.type.namespace, 'my.name.space'
+    end
+  end
+
+  def test_inherited_namespace_from_dotted_name
+    schema = Avro::Schema.parse <<-SCHEMA
+      {"type": "record", "name": "my.name.space.OuterRecord", "fields": [
+        {"name": "definition", "type": {
+          "type": "enum", "name": "InnerEnum", "symbols": ["HELLO", "WORLD"]
+        }},
+        {"name": "relativeReference", "type": "InnerEnum"},
+        {"name": "absoluteReference", "type": "my.name.space.InnerEnum"}
+      ]}
+    SCHEMA
+
+    assert_equal schema.name, 'OuterRecord'
+    assert_equal schema.fullname, 'my.name.space.OuterRecord'
+    assert_equal schema.namespace, 'my.name.space'
+    schema.fields.each do |field|
+      assert_equal field.type.name, 'InnerEnum'
+      assert_equal field.type.fullname, 'my.name.space.InnerEnum'
+      assert_equal field.type.namespace, 'my.name.space'
+    end
+  end
+
+  def test_nested_namespaces
+    schema = Avro::Schema.parse <<-SCHEMA
+      {"type": "record", "name": "outer.OuterRecord", "fields": [
+        {"name": "middle", "type": {
+          "type": "record", "name": "middle.MiddleRecord", "fields": [
+            {"name": "inner", "type": {
+              "type": "record", "name": "InnerRecord", "fields": [
+                {"name": "recursive", "type": "MiddleRecord"}
+              ]
+            }}
+          ]
+        }}
+      ]}
+    SCHEMA
+
+    assert_equal schema.name, 'OuterRecord'
+    assert_equal schema.fullname, 'outer.OuterRecord'
+    assert_equal schema.namespace, 'outer'
+    middle = schema.fields.first.type
+    assert_equal middle.name, 'MiddleRecord'
+    assert_equal middle.fullname, 'middle.MiddleRecord'
+    assert_equal middle.namespace, 'middle'
+    inner = middle.fields.first.type
+    assert_equal inner.name, 'InnerRecord'
+    assert_equal inner.fullname, 'middle.InnerRecord'
+    assert_equal inner.namespace, 'middle'
+    assert_equal inner.fields.first.type, middle
+  end
+
+  def test_to_avro_includes_namespaces
+    schema = Avro::Schema.parse <<-SCHEMA
+      {"type": "record", "name": "my.name.space.OuterRecord", "fields": [
+        {"name": "definition", "type": {
+          "type": "fixed", "name": "InnerFixed", "size": 16
+        }},
+        {"name": "reference", "type": "InnerFixed"}
+      ]}
+    SCHEMA
+
+    assert_equal schema.to_avro, {
+      'type' => 'record', 'name' => 'OuterRecord', 'namespace' => 'my.name.space',
+      'fields' => [
+        {'name' => 'definition', 'type' => {
+          'type' => 'fixed', 'name' => 'InnerFixed', 'namespace' => 'my.name.space',
+          'size' => 16
+        }},
+        {'name' => 'reference', 'type' => 'my.name.space.InnerFixed'}
+      ]
+    }
+  end
+
+  def test_unknown_named_type
+    error = assert_raise Avro::UnknownSchemaError do
+      Avro::Schema.parse <<-SCHEMA
+        {"type": "record", "name": "my.name.space.Record", "fields": [
+          {"name": "reference", "type": "MissingType"}
+        ]}
+      SCHEMA
+    end
+
+    assert_equal '"MissingType" is not a schema we know about.', error.message
+  end
+end