avro 1.7.4 → 1.7.5

data/test/random_data.rb

@@ -27,52 +27,52 @@ class RandomData
   end
 
   def nextdata(schm, d=0)
-    case schm.type
-    when 'boolean'
+    case schm.type_sym
+    when :boolean
       rand > 0.5
-    when 'string'
+    when :string
       randstr()
-    when 'int'
+    when :int
       rand(Avro::Schema::INT_MAX_VALUE - Avro::Schema::INT_MIN_VALUE) + Avro::Schema::INT_MIN_VALUE
-    when 'long'
+    when :long
       rand(Avro::Schema::LONG_MAX_VALUE - Avro::Schema::LONG_MIN_VALUE) + Avro::Schema::LONG_MIN_VALUE
-    when 'float'
+    when :float
       (-1024 + 2048 * rand).round.to_f
-    when 'double'
+    when :double
       Avro::Schema::LONG_MIN_VALUE + (Avro::Schema::LONG_MAX_VALUE - Avro::Schema::LONG_MIN_VALUE) * rand
-    when 'bytes'
+    when :bytes
       randstr(BYTEPOOL)
-    when 'null'
+    when :null
       nil
-    when 'array'
+    when :array
       arr = []
       len = rand(5) + 2 - d
       len = 0 if len < 0
       len.times{ arr << nextdata(schm.items, d+1) }
       arr
-    when 'map'
+    when :map
       map = {}
       len = rand(5) + 2 - d
       len = 0 if len < 0
       len.times do
-        map[nextdata(Avro::Schema::PrimitiveSchema.new('string'))] = nextdata(schm.values, d+1)
+        map[nextdata(Avro::Schema::PrimitiveSchema.new(:string))] = nextdata(schm.values, d+1)
       end
       map
-    when 'record', 'error'
+    when :record, :error
       m = {}
       schm.fields.each do |field|
         m[field.name] = nextdata(field.type, d+1)
       end
       m
-    when 'union'
+    when :union
       types = schm.schemas
       nextdata(types[rand(types.size)], d)
-    when 'enum'
+    when :enum
       symbols = schm.symbols
       len = symbols.size
       return nil if len == 0
       symbols[rand(len)]
-    when 'fixed'
+    when :fixed
       f = ""
       schm.size.times { f << BYTEPOOL[rand(BYTEPOOL.size), 1] }
       f

data/test/test_datafile.rb

@@ -154,4 +154,35 @@ JSON
     datafile.close
   end
 
+  def test_deflate
+    Avro::DataFile.open('data.avr', 'w', '"string"', :deflate) do |writer|
+      writer << 'a' * 10_000
+    end
+    assert(File.size('data.avr') < 500)
+
+    records = []
+    Avro::DataFile.open('data.avr') do |reader|
+      reader.each {|record| records << record }
+    end
+    assert_equal records, ['a' * 10_000]
+  end
+
+  def test_append_to_deflated_file
+    schema = Avro::Schema.parse('"string"')
+    writer = Avro::IO::DatumWriter.new(schema)
+    file = Avro::DataFile::Writer.new(File.open('data.avr', 'wb'), writer, schema, :deflate)
+    file << 'a' * 10_000
+    file.close
+
+    file = Avro::DataFile::Writer.new(File.open('data.avr', 'a+b'), writer)
+    file << 'b' * 10_000
+    file.close
+    assert(File.size('data.avr') < 1_000)
+
+    records = []
+    Avro::DataFile.open('data.avr') do |reader|
+      reader.each {|record| records << record }
+    end
+    assert_equal records, ['a' * 10_000, 'b' * 10_000]
+  end
 end

data/test/test_protocol.rb

@@ -189,4 +189,11 @@ EOS
       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,134 @@
+# 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
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: avro
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 1
   - 7
-  - 4
-  version: 1.7.4
+  - 5
+  version: 1.7.5
 platform: ruby
 authors: 
 - Apache Software Foundation
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-21 00:00:00 Z
+date: 2013-08-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: yajl-ruby
@@ -70,6 +70,7 @@ files:
 - test/test_protocol.rb
 - test/test_socket_transport.rb
 - test/tool.rb
+- test/test_schema.rb
 homepage: http://hadoop.apache.org/avro/
 licenses: []
 
@@ -112,4 +113,5 @@ test_files:
 - test/test_help.rb
 - test/test_protocol.rb
 - test/test_socket_transport.rb
+- test/test_schema.rb
 - test/test_io.rb