deimos-ruby 1.13.2 → 1.14.1

data/spec/generators/schema_class_generator_spec.rb

@@ -3,22 +3,27 @@
 require 'generators/deimos/schema_class_generator'
 require 'fileutils'
 
+class MultiFileSerializer
+  def dump(value)
+    value.keys.sort.map { |k| "#{k}:\n#{value[k]}\n" }.join("\n")
+  end
+end
+
 RSpec.describe Deimos::Generators::SchemaClassGenerator do
-  let(:schema_class_path) { 'app/lib/schema_classes/com/my-namespace' }
-  let(:expected_files) { Dir['spec/schema_classes/*.rb'] }
-  let(:files) { Dir["#{schema_class_path}/*.rb"] }
+  let(:schema_class_path) { 'spec/app/lib/schema_classes' }
+  let(:files) { Dir["#{schema_class_path}/*.rb"].map { |f| [f, File.read(f)]}.to_h }
 
   before(:each) do
     Deimos.config.reset!
     Deimos.configure do
       schema.path 'spec/schemas/'
-      schema.generated_class_path 'app/lib/schema_classes'
+      schema.generated_class_path 'spec/app/lib/schema_classes'
       schema.backend :avro_local
     end
   end
 
   after(:each) do
-    FileUtils.rm_rf(schema_class_path) if File.exist?(schema_class_path)
+    FileUtils.rm_rf('spec/app') if File.exist?('spec/app')
   end
 
   context 'with a Consumers Schema' do
@@ -32,19 +37,26 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config field: :a_string
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(1)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('consumers', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    it 'should generate a schema class for generated' do
-      generated_path = files.select { |f| f =~ /generated/ }.first
-      expected_path = expected_files.select { |f| f =~ /generated/ }.first
-
-      expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('consumers-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
+
   end
 
   context 'with a Consumers Schema with Complex types' do
@@ -58,18 +70,24 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config field: :a_string
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(1)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_complex_types', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    it 'should generate a schema class for my_schema_with_complex_types' do
-      generated_path = files.select { |f| f =~ /my_schema_with_complex_types/ }.first
-      expected_path = expected_files.select { |f| f =~ /my_schema_with_complex_types/ }.first
-
-      expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_complex_types-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
   end
 
@@ -84,18 +102,24 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config field: :a_string
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(1)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_circular', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    it 'should generate a schema class for my_schema_with_circular_reference' do
-      generated_path = files.select { |f| f =~ /my_schema_with_circular_reference/ }.first
-      expected_path = expected_files.select { |f| f =~ /my_schema_with_circular_reference/ }.first
-
-      expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_circular-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
   end
 
@@ -110,19 +134,23 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config schema: 'MySchema_key'
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(2)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('producers_with_key', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    %w(my_schema my_schema_key).each do |klass|
-      it "should generate a schema class for #{klass}" do
-        generated_path = files.select { |f| f =~ /#{klass}\.rb/ }.first
-        expected_path = expected_files.select { |f| f =~ /#{klass}\.rb/ }.first
-
-        expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('producers_with_key-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
       end
     end
   end
@@ -138,18 +166,24 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config field: :test_id
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(1)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_nested', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    it 'should generate a schema class for my_nested_schema' do
-      generated_path = files.select { |f| f =~ /my_nested_schema/ }.first
-      expected_path = expected_files.select { |f| f =~ /my_nested_schema/ }.first
-
-      expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_nested-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
   end
 
@@ -180,19 +214,23 @@ RSpec.describe Deimos::Generators::SchemaClassGenerator do
           key_config field: :test_id
         end
       end
-      described_class.start
     end
 
-    it 'should generate the correct number of classes' do
-      expect(files.length).to eq(4)
+    context 'nested true' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => true) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_and_producers', snapshot_serializer: MultiFileSerializer)
+        end
+      end
     end
 
-    %w(generated my_schema my_schema_key my_nested_schema).each do |klass|
-      it "should generate a schema class for #{klass}" do
-        generated_path = files.select { |f| f =~ /#{klass}\.rb/ }.first
-        expected_path = expected_files.select { |f| f =~ /#{klass}\.rb/ }.first
-
-        expect(File.read(generated_path)).to eq(File.read(expected_path))
+    context 'nested false' do
+      it 'should generate the correct classes' do
+        Deimos.with_config('schema.nest_child_schemas' => false) do
+          described_class.start
+          expect(files).to match_snapshot('consumers_and_producers-no-nest', snapshot_serializer: MultiFileSerializer)
+        end
       end
     end
   end

data/spec/producer_spec.rb

@@ -476,7 +476,7 @@ module ProducerTest
             test_id: 'foo',
             test_float: BigDecimal('123.456'),
             test_array: ['1'],
-            some_nested_record: Schemas::MyNestedRecord.new(
+            some_nested_record: Schemas::MyNestedSchema::MyNestedRecord.new(
               some_int: 123,
               some_float: BigDecimal('456.789'),
               some_string: '123',

data/spec/schemas/com/my-namespace/MySchemaId_key.avsc

@@ -0,0 +1,12 @@
+{
+  "namespace": "com.my-namespace",
+  "name": "MySchemaId_key",
+  "type": "record",
+  "doc": "Test schema",
+  "fields": [
+    {
+      "name": "id",
+      "type": "integer"
+    }
+  ]
+}

data/spec/schemas/generated.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.Generated
+  class Generated < Deimos::SchemaClass::Record
+
+    ### Secondary Schema Classes ###
+    # Autogenerated Schema for Record at com.my-namespace.ARecord
+    class ARecord < Deimos::SchemaClass::Record
+
+      ### Attribute Accessors ###
+      # @param value [String]
+      attr_accessor :a_record_field
+
+      # @override
+      def initialize(a_record_field: nil)
+        super
+        self.a_record_field = a_record_field
+      end
+
+      # @override
+      def schema
+        'ARecord'
+      end
+
+      # @override
+      def namespace
+        'com.my-namespace'
+      end
+
+      # @override
+      def to_h
+        {
+          'a_record_field' => @a_record_field
+        }
+      end
+    end
+
+    # Autogenerated Schema for Enum at com.my-namespace.AnEnum
+    class AnEnum < Deimos::SchemaClass::Enum
+      # @return ['sym1', 'sym2']
+      attr_accessor :an_enum
+
+      # :nodoc:
+      def initialize(an_enum)
+        super
+        self.an_enum = an_enum
+      end
+
+      # @override
+      def symbols
+        %w(sym1 sym2)
+      end
+
+      # @override
+      def to_h
+        @an_enum
+      end
+    end
+
+
+    ### Attribute Readers ###
+    # @return [AnEnum]
+    attr_reader :an_enum
+    # @return [ARecord]
+    attr_reader :a_record
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :a_string
+    # @param value [Integer]
+    attr_accessor :a_int
+    # @param value [Integer]
+    attr_accessor :a_long
+    # @param value [Float]
+    attr_accessor :a_float
+    # @param value [Float]
+    attr_accessor :a_double
+    # @param value [nil, Integer]
+    attr_accessor :an_optional_int
+    # @param values [Array<Integer>]
+    attr_accessor :an_array
+    # @param values [Hash<String, String>]
+    attr_accessor :a_map
+    # @param value [String]
+    attr_accessor :timestamp
+    # @param value [String]
+    attr_accessor :message_id
+
+    ### Attribute Writers ###
+    # @param value [AnEnum]
+    def an_enum=(value)
+      @an_enum = AnEnum.initialize_from_value(value)
+    end
+
+    # @param value [ARecord]
+    def a_record=(value)
+      @a_record = ARecord.initialize_from_value(value)
+    end
+
+    # @override
+    def initialize(a_string: nil,
+                   a_int: nil,
+                   a_long: nil,
+                   a_float: nil,
+                   a_double: nil,
+                   an_optional_int: nil,
+                   an_enum: nil,
+                   an_array: nil,
+                   a_map: nil,
+                   timestamp: nil,
+                   message_id: nil,
+                   a_record: nil)
+      super
+      self.a_string = a_string
+      self.a_int = a_int
+      self.a_long = a_long
+      self.a_float = a_float
+      self.a_double = a_double
+      self.an_optional_int = an_optional_int
+      self.an_enum = an_enum
+      self.an_array = an_array
+      self.a_map = a_map
+      self.timestamp = timestamp
+      self.message_id = message_id
+      self.a_record = a_record
+    end
+
+    # @override
+    def schema
+      'Generated'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'a_string' => @a_string,
+        'a_int' => @a_int,
+        'a_long' => @a_long,
+        'a_float' => @a_float,
+        'a_double' => @a_double,
+        'an_optional_int' => @an_optional_int,
+        'an_enum' => @an_enum&.to_h,
+        'an_array' => @an_array,
+        'a_map' => @a_map,
+        'timestamp' => @timestamp,
+        'message_id' => @message_id,
+        'a_record' => @a_record&.to_h
+      }
+    end
+  end
+end

data/spec/schemas/my_nested_schema.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MyNestedSchema
+  class MyNestedSchema < Deimos::SchemaClass::Record
+
+    ### Secondary Schema Classes ###
+    # Autogenerated Schema for Record at com.my-namespace.MyNestedRecord
+    class MyNestedRecord < Deimos::SchemaClass::Record
+
+      ### Attribute Accessors ###
+      # @param value [Integer]
+      attr_accessor :some_int
+      # @param value [Float]
+      attr_accessor :some_float
+      # @param value [String]
+      attr_accessor :some_string
+      # @param value [nil, Integer]
+      attr_accessor :some_optional_int
+
+      # @override
+      def initialize(some_int: nil,
+                     some_float: nil,
+                     some_string: nil,
+                     some_optional_int: nil)
+        super
+        self.some_int = some_int
+        self.some_float = some_float
+        self.some_string = some_string
+        self.some_optional_int = some_optional_int
+      end
+
+      # @override
+      def schema
+        'MyNestedRecord'
+      end
+
+      # @override
+      def namespace
+        'com.my-namespace'
+      end
+
+      # @override
+      def to_h
+        {
+          'some_int' => @some_int,
+          'some_float' => @some_float,
+          'some_string' => @some_string,
+          'some_optional_int' => @some_optional_int
+        }
+      end
+    end
+
+
+    ### Attribute Readers ###
+    # @return [MyNestedRecord]
+    attr_reader :some_nested_record
+    # @return [nil, MyNestedRecord]
+    attr_reader :some_optional_record
+
+    ### Attribute Accessors ###
+    # @param value [String]
+    attr_accessor :test_id
+    # @param value [Float]
+    attr_accessor :test_float
+    # @param values [Array<String>]
+    attr_accessor :test_array
+
+    ### Attribute Writers ###
+    # @param value [MyNestedRecord]
+    def some_nested_record=(value)
+      @some_nested_record = MyNestedRecord.initialize_from_value(value)
+    end
+
+    # @param value [nil, MyNestedRecord]
+    def some_optional_record=(value)
+      @some_optional_record = MyNestedRecord.initialize_from_value(value)
+    end
+
+    # @override
+    def initialize(test_id: nil,
+                   test_float: nil,
+                   test_array: nil,
+                   some_nested_record: nil,
+                   some_optional_record: nil)
+      super
+      self.test_id = test_id
+      self.test_float = test_float
+      self.test_array = test_array
+      self.some_nested_record = some_nested_record
+      self.some_optional_record = some_optional_record
+    end
+
+    # @override
+    def schema
+      'MyNestedSchema'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'test_id' => @test_id,
+        'test_float' => @test_float,
+        'test_array' => @test_array,
+        'some_nested_record' => @some_nested_record&.to_h,
+        'some_optional_record' => @some_optional_record&.to_h
+      }
+    end
+  end
+end

data/spec/{schema_classes → schemas}/my_schema.rb

@@ -5,6 +5,7 @@ module Schemas
   ### Primary Schema Class ###
   # Autogenerated Schema for Record at com.my-namespace.MySchema
   class MySchema < Deimos::SchemaClass::Record
+
     ### Attribute Readers ###
     # @return [MySchemaKey]
     attr_reader :payload_key

data/spec/{schema_classes → schemas}/my_schema_key.rb

@@ -5,6 +5,7 @@ module Schemas
   ### Primary Schema Class ###
   # Autogenerated Schema for Record at com.my-namespace.MySchema_key
   class MySchemaKey < Deimos::SchemaClass::Record
+
     ### Attribute Accessors ###
     # @param value [String]
     attr_accessor :test_id

data/spec/schemas/my_schema_with_circular_reference.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# This file is autogenerated by Deimos, Do NOT modify
+module Schemas
+  ### Primary Schema Class ###
+  # Autogenerated Schema for Record at com.my-namespace.MySchemaWithCircularReference
+  class MySchemaWithCircularReference < Deimos::SchemaClass::Record
+
+    ### Secondary Schema Classes ###
+    # Autogenerated Schema for Record at com.my-namespace.Property
+    class Property < Deimos::SchemaClass::Record
+
+      ### Attribute Accessors ###
+      # @param value [Boolean, Integer, Integer, Float, Float, String, Array<Property>, Hash<String, Property>]
+      attr_accessor :property
+
+      # @override
+      def initialize(property: nil)
+        super
+        self.property = property
+      end
+
+      # @override
+      def schema
+        'Property'
+      end
+
+      # @override
+      def namespace
+        'com.my-namespace'
+      end
+
+      # @override
+      def to_h
+        {
+          'property' => @property
+        }
+      end
+    end
+
+
+    ### Attribute Readers ###
+    # @return [Hash<String, Property>]
+    attr_reader :properties
+
+    ### Attribute Writers ###
+    # @param values [Hash<String, Property>]
+    def properties=(values)
+      @properties = values.transform_values do |value|
+        Property.initialize_from_value(value)
+      end
+    end
+
+    # @override
+    def initialize(properties: {})
+      super
+      self.properties = properties
+    end
+
+    # @override
+    def schema
+      'MySchemaWithCircularReference'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def to_h
+      {
+        'properties' => @properties.transform_values { |v| v&.to_h }
+      }
+    end
+  end
+end