deimos-ruby 1.24.2 → 2.0.0.pre.alpha1

data/spec/producer_spec.rb

@@ -5,27 +5,13 @@ module ProducerTest
   describe Deimos::Producer do
 
     prepend_before(:each) do
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic'
-        key_config field: 'test_id'
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MyProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchemaWithId'
-        namespace 'com.my-namespace'
-        topic 'my-topic'
-        key_config plain: true
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MyProducerWithID', producer_class)
 
       producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic'
-        key_config plain: true
         # :nodoc:
         def self.partition_key(payload)
           payload[:payload_key] ? payload[:payload_key] + '1' : nil
@@ -33,71 +19,90 @@ module ProducerTest
       end
       stub_const('MyNonEncodedProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic2'
-        key_config none: true
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MyNoKeyProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MyNestedSchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic'
-        key_config field: 'test_id'
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MyNestedSchemaProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic2'
-        key_config schema: 'MySchema_key'
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MySchemaProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic 'my-topic'
-      end
+      producer_class = Class.new(Deimos::Producer)
       stub_const('MyErrorProducer', producer_class)
 
-      producer_class = Class.new(Deimos::Producer) do
-        schema 'MySchema'
-        namespace 'com.my-namespace'
-        topic nil
-        key_config none: true
+      Karafka::App.routes.redraw do
+        topic 'my-topic' do
+          producer_class MyProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config field: 'test_id'
+        end
+        topic 'a-new-topic' do
+          producer_class MyProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config field: 'test_id'
+        end
+        topic 'my-topic-with-id' do
+          producer_class MyProducerWithID
+          schema 'MySchemaWithId'
+          namespace 'com.my-namespace'
+          key_config plain: true
+        end
+        topic 'my-topic-non-encoded' do
+          producer_class MyNonEncodedProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config plain: true
+        end
+        topic 'my-topic-no-key' do
+          producer_class MyNoKeyProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config none: true
+        end
+        topic 'my-topic-nested-schema' do
+          producer_class MyNestedSchemaProducer
+          schema 'MyNestedSchema'
+          namespace 'com.my-namespace'
+          key_config field: 'test_id'
+        end
+        topic 'my-topic-schema' do
+          producer_class MySchemaProducer
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          key_config schema: 'MySchema_key'
+        end
+        topic 'my-topic-error' do
+          schema 'MySchema'
+          namespace 'com.my-namespace'
+          producer_class MyErrorProducer
+        end
       end
-      stub_const('MyNoTopicProducer', producer_class)
 
     end
 
-    it 'should fail on invalid message with error handler' do
-      subscriber = Deimos.subscribe('produce') do |event|
-        expect(event.payload[:payloads]).to eq([{ 'invalid' => 'key' }])
-      end
-      expect(MyProducer.encoder).to receive(:validate).and_raise('OH NOES')
+    it 'should fail on invalid message' do
+      expect(Deimos::ProducerMiddleware).to receive(:call).and_raise('OH NOES')
       expect { MyProducer.publish({ 'invalid' => 'key', :payload_key => 'key' }) }.
         to raise_error('OH NOES')
-      Deimos.unsubscribe(subscriber)
     end
 
     it 'should produce a message' do
-      expect(described_class).to receive(:produce_batch).once.with(
-        Deimos::Backends::Test,
+      expect(MyProducer).to receive(:produce_batch).once.with(
+        Deimos::Backends::Kafka,
         [
-          Deimos::Message.new({ 'test_id' => 'foo', 'some_int' => 123 },
-                              MyProducer,
-                              topic: 'my-topic',
-                              partition_key: 'foo',
-                              key: 'foo'),
-          Deimos::Message.new({ 'test_id' => 'bar', 'some_int' => 124 },
-                              MyProducer,
-                              topic: 'my-topic',
-                              partition_key: 'bar',
-                              key: 'bar')
+          hash_including({
+            payload: { 'test_id' => 'foo', 'some_int' => 123 },
+            topic: 'my-topic',
+            partition_key: nil
+          }),
+          hash_including({
+            payload: { 'test_id' => 'bar', 'some_int' => 124 },
+            topic: 'my-topic',
+            partition_key: nil
+          })
         ]
       ).and_call_original
 
@@ -105,27 +110,27 @@ module ProducerTest
         [{ 'test_id' => 'foo', 'some_int' => 123 },
          { 'test_id' => 'bar', 'some_int' => 124 }]
       )
-      expect('my-topic').to have_sent('test_id' => 'foo', 'some_int' => 123)
+      expect('my-topic').to have_sent({'test_id' => 'foo', 'some_int' => 123}, 'foo', 'foo')
       expect('your-topic').not_to have_sent('test_id' => 'foo', 'some_int' => 123)
       expect('my-topic').not_to have_sent('test_id' => 'foo2', 'some_int' => 123)
     end
 
     it 'should allow setting the topic and headers from publish_list' do
-      expect(described_class).to receive(:produce_batch).once.with(
-        Deimos::Backends::Test,
+      expect(MyProducer).to receive(:produce_batch).once.with(
+        Deimos::Backends::Kafka,
         [
-          Deimos::Message.new({ 'test_id' => 'foo', 'some_int' => 123 },
-                              MyProducer,
-                              topic: 'a-new-topic',
-                              headers: { 'foo' => 'bar' },
-                              partition_key: 'foo',
-                              key: 'foo'),
-          Deimos::Message.new({ 'test_id' => 'bar', 'some_int' => 124 },
-                              MyProducer,
-                              topic: 'a-new-topic',
-                              headers: { 'foo' => 'bar' },
-                              partition_key: 'bar',
-                              key: 'bar')
+          hash_including({
+            payload: { 'test_id' => 'foo', 'some_int' => 123 },
+            topic: 'a-new-topic',
+            headers: { 'foo' => 'bar' },
+            partition_key: nil
+          }),
+          hash_including({
+            payload: { 'test_id' => 'bar', 'some_int' => 124 },
+            topic: 'a-new-topic',
+            headers: { 'foo' => 'bar' },
+            partition_key: nil
+          })
         ]
       ).and_call_original
 
@@ -145,27 +150,14 @@ module ProducerTest
                   'some_int' => 123,
                   'message_id' => a_kind_of(String),
                   'timestamp' => a_kind_of(String) }
-      expect(described_class).to receive(:produce_batch).once do |_, messages|
-        expect(messages.size).to eq(1)
-        expect(messages[0].to_h).
-          to match(
-            payload: payload,
-            topic: 'my-topic',
-            partition_key: 'key',
-            metadata: {
-              producer_name: 'MyProducerWithID',
-              decoded_payload: payload
-            },
-            key: 'key'
-          )
-      end
       MyProducerWithID.publish_list(
         [{ 'test_id' => 'foo', 'some_int' => 123, :payload_key => 'key' }]
       )
+      expect(MyProducerWithID.topic).to have_sent(payload, 'key', 'key')
+
     end
 
     it 'should not publish if publish disabled' do
-      expect(described_class).not_to receive(:produce_batch)
       Deimos.configure { |c| c.producers.disabled = true }
       MyProducer.publish_list(
         [{ 'test_id' => 'foo', 'some_int' => 123 },
@@ -201,102 +193,22 @@ module ProducerTest
     it 'should produce to a prefixed topic' do
       Deimos.configure { |c| c.producers.topic_prefix = 'prefix.' }
       payload = { 'test_id' => 'foo', 'some_int' => 123 }
-      expect(described_class).to receive(:produce_batch).once do |_, messages|
-        expect(messages.size).to eq(1)
-        expect(messages[0].to_h).
-          to eq(
-            payload: payload,
-            topic: 'prefix.my-topic',
-            partition_key: 'foo',
-            metadata: {
-              producer_name: 'MyProducer',
-              decoded_payload: payload
-            },
-            key: 'foo'
-          )
-      end
 
       MyProducer.publish_list([payload])
-      Deimos.configure { |c| c.producers.topic_prefix = nil }
-      expect(described_class).to receive(:produce_batch).once do |_, messages|
-        expect(messages.size).to eq(1)
-        expect(messages[0].to_h).
-          to eq(
-            payload: payload,
-            topic: 'my-topic',
-            partition_key: 'foo',
-            metadata: {
-              producer_name: 'MyProducer',
-              decoded_payload: payload
-            },
-            key: 'foo'
-          )
-      end
+      expect('prefix.my-topic').to have_sent(payload, 'foo', 'foo')
+      expect(karafka.produced_messages.size).to eq(1)
+      karafka.produced_messages.clear
 
-      MyProducer.publish_list(
-        [{ 'test_id' => 'foo', 'some_int' => 123 }]
-      )
-    end
-
-    it 'should encode the key' do
       Deimos.configure { |c| c.producers.topic_prefix = nil }
-      expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
-      expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'bar', topic: 'my-topic-key')
-      expect(MyProducer.encoder).to receive(:encode).with({
-                                                            'test_id' => 'foo',
-                                                            'some_int' => 123
-                                                          }, { topic: 'my-topic-value' })
-      expect(MyProducer.encoder).to receive(:encode).with({
-                                                            'test_id' => 'bar',
-                                                            'some_int' => 124
-                                                          }, { topic: 'my-topic-value' })
 
       MyProducer.publish_list(
-        [{ 'test_id' => 'foo', 'some_int' => 123 },
-         { 'test_id' => 'bar', 'some_int' => 124 }]
-      )
-    end
-
-    it 'should encode the key with topic prefix' do
-      Deimos.configure { |c| c.producers.topic_prefix = 'prefix.' }
-      expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'prefix.my-topic-key')
-      expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'bar', topic: 'prefix.my-topic-key')
-      expect(MyProducer.encoder).to receive(:encode).with({  'test_id' => 'foo',
-                                                             'some_int' => 123 },
-                                                          { topic: 'prefix.my-topic-value' })
-      expect(MyProducer.encoder).to receive(:encode).with({  'test_id' => 'bar',
-                                                             'some_int' => 124 },
-                                                          { topic: 'prefix.my-topic-value' })
-
-      MyProducer.publish_list([{ 'test_id' => 'foo', 'some_int' => 123 },
-                               { 'test_id' => 'bar', 'some_int' => 124 }])
-    end
-
-    it 'should not encode with plaintext key' do
-      expect(MyNonEncodedProducer.key_encoder).not_to receive(:encode_key)
-
-      MyNonEncodedProducer.publish_list(
-        [{ 'test_id' => 'foo', 'some_int' => 123, :payload_key => 'foo_key' },
-         { 'test_id' => 'bar', 'some_int' => 124, :payload_key => 'bar_key' }]
-      )
-    end
-
-    it 'should encode with a schema' do
-      expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'foo_key' },
-                                                                    { topic: 'my-topic2-key' })
-      expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'bar_key' },
-                                                                    { topic: 'my-topic2-key' })
-
-      MySchemaProducer.publish_list(
-        [{ 'test_id' => 'foo', 'some_int' => 123,
-           :payload_key => { 'test_id' => 'foo_key' } },
-         { 'test_id' => 'bar', 'some_int' => 124,
-           :payload_key => { 'test_id' => 'bar_key' } }]
+        [{ 'test_id' => 'foo', 'some_int' => 123 }]
       )
+      expect('my-topic').to have_sent(payload, 'foo', 'foo')
+      expect(karafka.produced_messages.size).to eq(1)
     end
 
     it 'should properly encode and coerce values with a nested record' do
-      expect(MyNestedSchemaProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
       MyNestedSchemaProducer.publish({
         'test_id' => 'foo',
         'test_float' => BigDecimal('123.456'),
@@ -323,39 +235,6 @@ module ProducerTest
       )
     end
 
-    it 'should raise error if blank topic is passed in explicitly' do
-      expect {
-        MyProducer.publish_list(
-          [{  'test_id' => 'foo',
-              'some_int' => 123 },
-           {  'test_id' => 'bar',
-              'some_int' => 124 }],
-          topic: ''
-        )
-      }.to raise_error(RuntimeError,
-                       'Topic not specified. Please specify the topic.')
-    end
-
-    it 'should raise error if the producer has not been initialized with a topic' do
-      expect {
-        MyNoTopicProducer.publish_list(
-          [{  'test_id' => 'foo',
-              'some_int' => 123 },
-           {  'test_id' => 'bar',
-              'some_int' => 124 }]
-        )
-      }.to raise_error(RuntimeError,
-                       'Topic not specified. Please specify the topic.')
-    end
-
-    it 'should error with nothing set' do
-      expect {
-        MyErrorProducer.publish_list(
-          [{ 'test_id' => 'foo', 'some_int' => 123, :payload_key => '123' }]
-        )
-      }.to raise_error('No key config given - if you are not encoding keys, please use `key_config plain: true`')
-    end
-
     it 'should error if no key given and none is not the config' do
       expect {
         MyNonEncodedProducer.publish_list(
@@ -395,30 +274,25 @@ module ProducerTest
 
     context 'with Schema Class payloads' do
       it 'should fail on invalid message with error handler' do
-        subscriber = Deimos.subscribe('produce') do |event|
-          expect(event.payload[:payloads]).to eq([{ 'invalid' => 'key' }])
-        end
-        expect(MyProducer.encoder).to receive(:validate).and_raise('OH NOES')
-        expect {
-          MyProducer.publish(Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 'invalid'))
-        }.to raise_error('OH NOES')
-        Deimos.unsubscribe(subscriber)
+        expect(Deimos::ProducerMiddleware).to receive(:call).and_raise('OH NOES')
+        expect { MyProducer.publish(Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 'invalid')) }.
+          to raise_error('OH NOES')
       end
 
       it 'should produce a message' do
-        expect(described_class).to receive(:produce_batch).once.with(
-          Deimos::Backends::Test,
+        expect(MyProducer).to receive(:produce_batch).once.with(
+          Deimos::Backends::Kafka,
           [
-            Deimos::Message.new({ 'test_id' => 'foo', 'some_int' => 123 },
-                                MyProducer,
-                                topic: 'my-topic',
-                                partition_key: 'foo',
-                                key: 'foo'),
-            Deimos::Message.new({ 'test_id' => 'bar', 'some_int' => 124 },
-                                MyProducer,
-                                topic: 'my-topic',
-                                partition_key: 'bar',
-                                key: 'bar')
+            hash_including({
+              payload: { 'test_id' => 'foo', 'some_int' => 123, 'payload_key' => nil },
+              topic: 'my-topic',
+              partition_key: nil,
+            }),
+            hash_including({
+              payload: { 'test_id' => 'bar', 'some_int' => 124, 'payload_key' => nil },
+              topic: 'my-topic',
+              partition_key: nil
+            })
           ]
         ).and_call_original
 
@@ -432,7 +306,7 @@ module ProducerTest
       end
 
       it 'should not publish if publish disabled' do
-        expect(described_class).not_to receive(:produce_batch)
+        expect(MyProducer).not_to receive(:produce_batch)
         Deimos.configure { |c| c.producers.disabled = true }
         MyProducer.publish_list(
           [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123),
@@ -443,16 +317,6 @@ module ProducerTest
 
       it 'should encode the key' do
         Deimos.configure { |c| c.producers.topic_prefix = nil }
-        expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
-        expect(MyProducer.encoder).to receive(:encode_key).with('test_id', 'bar', topic: 'my-topic-key')
-        expect(MyProducer.encoder).to receive(:encode).with({
-                                                              'test_id' => 'foo',
-                                                              'some_int' => 123
-                                                            }, { topic: 'my-topic-value' })
-        expect(MyProducer.encoder).to receive(:encode).with({
-                                                              'test_id' => 'bar',
-                                                              'some_int' => 124
-                                                            }, { topic: 'my-topic-value' })
 
         MyProducer.publish_list(
           [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123),
@@ -461,11 +325,6 @@ module ProducerTest
       end
 
       it 'should encode with a schema' do
-        expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'foo_key' },
-                                                                      { topic: 'my-topic2-key' })
-        expect(MySchemaProducer.key_encoder).to receive(:encode).with({ 'test_id' => 'bar_key' },
-                                                                      { topic: 'my-topic2-key' })
-
         MySchemaProducer.publish_list(
           [Schemas::MyNamespace::MySchema.new(test_id: 'foo', some_int: 123, payload_key: { 'test_id' => 'foo_key' }),
            Schemas::MyNamespace::MySchema.new(test_id: 'bar', some_int: 124, payload_key: { 'test_id' => 'bar_key' })]
@@ -473,7 +332,6 @@ module ProducerTest
       end
 
       it 'should properly encode and coerce values with a nested record' do
-        expect(MyNestedSchemaProducer.encoder).to receive(:encode_key).with('test_id', 'foo', topic: 'my-topic-key')
         MyNestedSchemaProducer.publish(
           Schemas::MyNamespace::MyNestedSchema.new(
             test_id: 'foo',
@@ -524,7 +382,7 @@ module ProducerTest
         MyProducerWithID.publish({
           'test_id' => 'foo', 'some_int' => 123, :payload_key => 123
                                  })
-        expect('my-topic').
+        expect('my-topic-with-id').
           to have_sent('test_id' => 'foo', 'some_int' => 123,
                        'message_id' => anything, 'timestamp' => anything)
         expect(Deimos).not_to be_producers_disabled
@@ -544,7 +402,7 @@ module ProducerTest
                                  :payload_key => '123'
                                })
             expect('my-topic').not_to have_sent(anything)
-            expect('my-topic2').to have_sent('test_id' => 'foo', 'some_int' => 123)
+            expect('my-topic-schema').to have_sent('test_id' => 'foo', 'some_int' => 123)
             expect(Deimos).not_to be_producers_disabled
             expect(Deimos).to be_producers_disabled(MyProducer)
             expect(Deimos).not_to be_producers_disabled(MySchemaProducer)
@@ -582,11 +440,11 @@ module ProducerTest
       end
 
       it 'should return db if db is set' do
-        Deimos.configure { producers.backend = :db }
+        Deimos.configure { producers.backend = :outbox }
         expect(described_class.determine_backend_class(true, false)).
-          to eq(Deimos::Backends::Db)
+          to eq(Deimos::Backends::Outbox)
         expect(described_class.determine_backend_class(false, false)).
-          to eq(Deimos::Backends::Db)
+          to eq(Deimos::Backends::Outbox)
       end
 
       it 'should return kafka if force_send is true' do

data/spec/rake_spec.rb

@@ -11,9 +11,7 @@ end
 
 describe 'Rakefile' do
   it 'should start listeners' do
-    runner = instance_double(Phobos::CLI::Runner)
-    expect(Phobos::CLI::Runner).to receive(:new).and_return(runner)
-    expect(runner).to receive(:run!)
+    expect(Karafka::Server).to receive(:run)
     Rake::Task['deimos:start'].invoke
   end
 end

data/spec/schema_backends/avro_validation_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe Deimos::SchemaBackends::AvroValidation do
 
   it 'should encode and decode correctly' do
     results = backend.encode(payload)
-    expect(results).to eq(payload)
+    expect(results).to eq(payload.to_json)
     results = backend.decode(results)
     expect(results).to eq(payload)
   end

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

@@ -0,0 +1,22 @@
+{
+  "namespace": "com.my-namespace",
+  "name": "MySchemaWithTitle",
+  "type": "record",
+  "doc": "Test schema",
+  "fields": [
+    {
+      "name": "test_id",
+      "type": "string",
+      "doc": "test string"
+    },
+    {
+      "name": "some_int",
+      "type": "int",
+      "doc": "test int"
+    },
+    {
+      "name": "title",
+      "type": "string"
+    }
+  ]
+}

data/spec/snapshots/consumers-no-nest.snap

@@ -950,6 +950,55 @@ module Schemas
 end
 
 
+spec/app/lib/schema_classes/my_schema_with_title.rb:
+# 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.MySchemaWithTitle
+  class MySchemaWithTitle < Deimos::SchemaClass::Record
+
+    ### Attribute Accessors ###
+    # @return [String]
+    attr_accessor :test_id
+    # @return [Integer]
+    attr_accessor :some_int
+    # @return [String]
+    attr_accessor :title
+
+    # @override
+    def initialize(test_id: nil,
+                   some_int: nil,
+                   title: nil)
+      super
+      self.test_id = test_id
+      self.some_int = some_int
+      self.title = title
+    end
+
+    # @override
+    def schema
+      'MySchemaWithTitle'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def as_json(_opts={})
+      {
+        'test_id' => @test_id,
+        'some_int' => @some_int,
+        'title' => @title
+      }
+    end
+  end
+end
+
+
 spec/app/lib/schema_classes/my_schema_with_unique_id.rb:
 # frozen_string_literal: true
 

data/spec/snapshots/consumers.snap

@@ -1010,6 +1010,55 @@ module Schemas
 end
 
 
+spec/app/lib/schema_classes/my_schema_with_title.rb:
+# 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.MySchemaWithTitle
+  class MySchemaWithTitle < Deimos::SchemaClass::Record
+
+    ### Attribute Accessors ###
+    # @return [String]
+    attr_accessor :test_id
+    # @return [Integer]
+    attr_accessor :some_int
+    # @return [String]
+    attr_accessor :title
+
+    # @override
+    def initialize(test_id: nil,
+                   some_int: nil,
+                   title: nil)
+      super
+      self.test_id = test_id
+      self.some_int = some_int
+      self.title = title
+    end
+
+    # @override
+    def schema
+      'MySchemaWithTitle'
+    end
+
+    # @override
+    def namespace
+      'com.my-namespace'
+    end
+
+    # @override
+    def as_json(_opts={})
+      {
+        'test_id' => @test_id,
+        'some_int' => @some_int,
+        'title' => @title
+      }
+    end
+  end
+end
+
+
 spec/app/lib/schema_classes/my_schema_with_unique_id.rb:
 # frozen_string_literal: true