nulogy_message_bus_producer 3.2.1 → 3.6.0

data/spec/integration/lib/nulogy_message_bus_producer/config_spec.rb

@@ -0,0 +1,37 @@
+require "integration_spec_helper"
+
+module NulogyMessageBusProducer
+  RSpec.describe Config do
+    let(:config) { described_class.new }
+
+    describe "add_subscription" do
+      it "adds a subscription" do
+        id = SecureRandom.uuid
+        group_id = SecureRandom.uuid
+        query = <<~QUERY
+          subscription {
+            testCreated(subscriptionId: "#{id}", subscriptionGroupId: "#{group_id}", topicName: "test-topic") {
+              foo {
+                id
+              }
+            }
+          }
+        QUERY
+
+        config.add_subscription!(
+          schema: "NulogyMessageBusProducer::Specs::TestSchema",
+          query: query
+        )
+
+        expect(config.configured_subscriptions).to include(having_attributes(
+          id: id,
+          subscription_group_id: group_id,
+          schema_key: "test",
+          event_type: "testCreated",
+          topic_name: "test-topic",
+          query: query
+        ))
+      end
+    end
+  end
+end

data/spec/integration/lib/nulogy_message_bus_producer/repopulate_replication_slots_spec.rb

@@ -5,8 +5,8 @@ RSpec.describe NulogyMessageBusProducer::RepopulateReplicationSlots do
   let(:company_uuid) { SecureRandom.uuid }
   let(:number_of_messages) { 100 }
 
-  let(:kafka_bootstrap_servers) { "host.docker.internal:39092" }
-  let(:kafka_connect) { KafkaConnect.new("http://localhost:8083", "ruby_specs") }
+  let(:kafka_bootstrap_servers) { "kafka:39093" }
+  let(:kafka_connect) { KafkaConnect.new("http://debezium:8083", "ruby_specs") }
   let(:replication_slot_name) { "rspec_replication_slot" }
   let(:topic_name) { "repopulate_replication_slot_tests" }
 
@@ -14,12 +14,12 @@ RSpec.describe NulogyMessageBusProducer::RepopulateReplicationSlots do
     cleanup_everything
   end
 
-  it "generates events" do
+  it "generates events", skip: flakey_in_ci do
     Kafka.create_topic(topic_name)
     consumer = Kafka.setup_kafka_consumer(topic_name)
 
     without_transaction do
-      subscribe_to(event_type: "testCreated", topic_name: topic_name)
+      self_serve_subscription(event_type: "testCreated", topic_name: topic_name)
 
       number_of_messages.times { |n| create_event(uuid(n)) }
 
@@ -38,7 +38,7 @@ RSpec.describe NulogyMessageBusProducer::RepopulateReplicationSlots do
     truncate_db
     begin
       Kafka.delete_topic(topic_name)
-    rescue StandardError
+    rescue
       nil
     end
     kafka_connect.delete
@@ -88,9 +88,8 @@ RSpec.describe NulogyMessageBusProducer::RepopulateReplicationSlots do
 
     {
       "bootstrap.servers": kafka_bootstrap_servers,
-
       "database.dbname": db_config["database"],
-      "database.hostname": db_config["host"] == "localhost" ? "host.docker.internal" : db_config["host"],
+      "database.hostname": db_config["host"],
       "database.password": db_config["password"],
       "database.port": db_config["port"] || 5432,
       "database.server.name": "test-environment",

data/spec/integration/lib/nulogy_message_bus_producer/subscription_spec.rb

@@ -1,61 +1,7 @@
 require "integration_spec_helper"
 
-RSpec.describe NulogyMessageBusProducer::Subscription do
-  context "when validating" do
-    it "is invalid with a blank query" do
-      model = build_subscription(query: "")
-
-      model.validate
-
-      expect(model.errors[:query]).to contain_exactly("can't be blank")
-    end
-
-    it "is invalid with blank schema_key" do
-      model = build_subscription(schema_key: "")
-
-      model.validate
-
-      expect(model.errors[:schema_key]).to contain_exactly("can't be blank")
-    end
-
-    it "is invalid with an invalid schema_key" do
-      model = build_subscription(schema_key: "invalid")
-
-      model.validate
-
-      expect(model.errors[:query]).to contain_exactly(/Could not find a schema for schema_key 'invalid'/)
-    end
-
-    it "is invalid with an invalid query" do
-      model = build_subscription(
-        query: subscription_query(query: "foo { a_field_that_does_not_exist }")
-      )
-
-      model.validate
-
-      expect(model).not_to be_valid
-      expect(model.errors[:query]).to contain_exactly(
-        "Field 'a_field_that_does_not_exist' doesn't exist on type 'testObject' (id: <new_record>)"
-      )
-    end
-
-    it "valid with a valid query" do
-      model = build_subscription(
-        query: subscription_query(query: "foo { id }")
-      )
-
-      model.validate
-
-      expect(model.errors).not_to include(:query)
-    end
-  end
-
-  def build_subscription(overrides = {})
-    attrs = {
-      schema_key: "test",
-      query: subscription_query
-    }.merge(overrides)
-
-    NulogyMessageBusProducer::Subscription.new(attrs)
+module NulogyMessageBusProducer
+  RSpec.describe SelfServeSubscription do
+    include_examples "subscription validations"
   end
 end

data/spec/integration/lib/nulogy_message_bus_producer/subscriptions/finder_spec.rb

@@ -0,0 +1,54 @@
+require "integration_spec_helper"
+
+module NulogyMessageBusProducer
+  module Subscriptions
+    RSpec.describe Finder, :subscriptions do
+      subject(:resolver) do
+        described_class.new(NulogyMessageBusProducer.config)
+      end
+
+      context "when there are only self-serve subscriptions" do
+        it "returns matching self-serve subscriptions" do
+          create_subscriptions = [self_serve_subscription, self_serve_subscription]
+          self_serve_subscription(event_type: "testUpdated")
+
+          expect(resolver.for_schema_event("test", "testCreated")).to contain_exactly(*create_subscriptions)
+        end
+      end
+
+      context "when there are only configured subscriptions" do
+        it "returns matching configured subscriptions" do
+          create_subscriptions = [configured_subscription, configured_subscription]
+          configured_subscription(event_type: "testUpdated")
+
+          expect(resolver.for_schema_event("test", "testCreated")).to contain_exactly(*create_subscriptions)
+        end
+      end
+
+      context "with both present" do
+        it "returns both" do
+          sub_1 = self_serve_subscription
+          sub_2 = configured_subscription
+
+          expect(resolver.for_schema_event("test", "testCreated")).to contain_exactly(
+            sub_1,
+            sub_2
+          )
+        end
+
+        context "when duplicate subscription ids are present" do
+          it "return the configured one" do
+            id = SecureRandom.uuid
+            self_serve_subscription(subscription_id: id, topic_name: "self-served")
+            configured_subscription(subscription_id: id, topic_name: "configured")
+
+            # Since the IDs are the same, we need to match on attributes to show that are different
+            expect(resolver.for_schema_event("test", "testCreated")).to contain_exactly(
+              have_attributes(topic_name: "configured")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/lib/nulogy_message_bus_producer/subscriptions/no_variables_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe NulogyMessageBusProducer::Subscriptions::NoVariables do
     )
 
     expect(result).to include_json(
-      errors: [{ message: include("Subscriptions should not be created with arguments") }]
+      errors: [{message: include("Subscriptions should not be created with arguments")}]
     )
   end
 

data/spec/integration/lib/nulogy_message_bus_producer/subscriptions/postgres_transport_spec.rb

@@ -1,81 +1,127 @@
 require "integration_spec_helper"
 
-RSpec.describe NulogyMessageBusProducer::Subscriptions::PostgresTransport do
+RSpec.describe NulogyMessageBusProducer::Subscriptions::PostgresTransport, :subscriptions do
   context "when subscription is triggered" do
     let(:company_uuid) { SecureRandom.uuid }
-
-    it "generates an event for a subscription" do
-      subscription = subscribe_to(
-        event_type: "testCreated",
-        topic_name: "some_topic"
-      )
-      root_object = {
-        foo: { id: "some id" },
+    let(:root_object) do
+      {
+        foo: {id: "some id"},
         company_uuid: company_uuid
       }
+    end
 
-      trigger_event("testCreated", root_object)
+    context "with self-serve subscriptions" do
+      it "generates an event for a subscription" do
+        subscription = self_serve_subscription(
+          event_type: "testCreated",
+          topic_name: "some_topic"
+        )
 
-      event = NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: subscription.id)
-      expect(event).to have_attributes(
-        partition_key: "#{subscription.subscription_group_id},#{company_uuid}",
-        topic_name: "some_topic",
-        event_json: include_json(testCreated: { foo: { id: "some id" } }),
-        company_uuid: company_uuid
-      )
-    end
+        trigger_event("testCreated", root_object)
 
-    it "allows configuring context" do
-      NulogyMessageBusProducer.config.context_for_subscription = lambda do |_|
-        { context_data: "some contextual information" }
+        event = NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: subscription.id)
+        expect(event).to have_attributes(
+          partition_key: "#{subscription.subscription_group_id},#{company_uuid}",
+          topic_name: "some_topic",
+          event_json: include_json(testCreated: {foo: {id: "some id"}}),
+          company_uuid: company_uuid
+        )
       end
-      subscription = subscribe_to(
-        event_type: "testCreated",
-        query: <<~GRAPHQL
-          foo {
-            contextData
-          }
-        GRAPHQL
-      )
-      root_object = {
-        foo: {},
-        company_uuid: company_uuid
-      }
 
-      trigger_event("testCreated", root_object)
+      it "allows configuring context" do
+        NulogyMessageBusProducer.config.context_for_subscription = lambda do |_|
+          {context_data: "some contextual information"}
+        end
+        subscription = self_serve_subscription(
+          event_type: "testCreated",
+          query: <<~GRAPHQL
+            foo {
+              contextData
+            }
+          GRAPHQL
+        )
+
+        trigger_event("testCreated", root_object)
+
+        event = NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: subscription.id)
+        expect(event).to have_attributes(
+          event_json: include_json(testCreated: {foo: {contextData: "some contextual information"}})
+        )
+      end
+
+      it "generates one event per subscription" do
+        self_serve_subscription(event_type: "testCreated")
+        self_serve_subscription(event_type: "testCreated")
+
+        expect {
+          trigger_event("testCreated", root_object)
+        }.to change(NulogyMessageBusProducer::SubscriptionEvent, :count).by(2)
 
-      event = NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: subscription.id)
-      expect(event).to have_attributes(
-        event_json: include_json(testCreated: { foo: { contextData: "some contextual information" } })
-      )
+        event_data = NulogyMessageBusProducer::SubscriptionEvent.pluck(:event_json)
+        expect(event_data).to all(
+          include_json(testCreated: {foo: {id: "some id"}})
+        )
+      end
     end
 
-    it "generates one event per subscription" do
-      subscribe_to(event_type: "testCreated")
-      subscribe_to(event_type: "testCreated")
+    context "with configured subscriptions" do
+      it "generates an event for a subscription" do
+        subscription = configured_subscription(
+          event_type: "testCreated",
+          topic_name: "some_topic"
+        )
 
-      expect do
-        root_object = {
-          foo: { id: "some id" },
-          company_uuid: company_uuid
-        }
         trigger_event("testCreated", root_object)
-      end.to change(NulogyMessageBusProducer::SubscriptionEvent, :count).by(2)
 
-      event_data = NulogyMessageBusProducer::SubscriptionEvent.pluck(:event_json)
-      expect(event_data).to all(
-        include_json(testCreated: { foo: { id: "some id" } })
-      )
+        event = NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: subscription.id)
+        expect(event).to have_attributes(
+          partition_key: "#{subscription.subscription_group_id},#{company_uuid}",
+          topic_name: "some_topic",
+          event_json: include_json(testCreated: {foo: {id: "some id"}}),
+          company_uuid: company_uuid
+        )
+      end
+    end
+
+    context "with both types of subscriptions" do
+      it "generates multiple events" do
+        self_served = self_serve_subscription(event_type: "testCreated", topic_name: "self_serve_topic")
+        configured = configured_subscription(event_type: "testCreated", topic_name: "configured_topic")
+
+        expect {
+          trigger_event("testCreated", root_object)
+        }.to change(NulogyMessageBusProducer::SubscriptionEvent, :count).by(2)
+        expect(NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: self_served.id)).to have_attributes(topic_name: "self_serve_topic")
+        expect(NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: configured.id)).to have_attributes(topic_name: "configured_topic")
+      end
+
+      context "when different types of subscriptions have the same id" do
+        it "generates events for only the configured subscription" do
+          id = SecureRandom.uuid
+          self_serve_subscription(subscription_id: id, topic_name: "self_serve_topic")
+          configured_subscription(subscription_id: id, topic_name: "configured_topic")
+
+          root_object = {
+            foo: {id: "some id"},
+            company_uuid: company_uuid
+          }
+
+          expect {
+            trigger_event("testCreated", root_object)
+          }.to change(NulogyMessageBusProducer::SubscriptionEvent, :count).by(1)
+          expect(NulogyMessageBusProducer::SubscriptionEvent.find_by!(subscription_id: id)).to have_attributes(topic_name: "configured_topic")
+        end
+      end
     end
   end
 
   context "when the class is not registered" do
     it "raises" do
-      expect do
+      expect {
         Class.new(GraphQL::Schema) do
           use(NulogyMessageBusProducer::Subscriptions::PostgresTransport)
         end
-      end.to raise_error(KeyError, /The schema registry did not contain an entry/)
+      }.to raise_error(KeyError, /The schema registry did not contain an entry/)
     end
   end
 
@@ -116,7 +162,7 @@ RSpec.describe NulogyMessageBusProducer::Subscriptions::PostgresTransport do
   def trigger_erroneous_subscription
     event_type = "testCreated"
 
-    subscription = subscribe_to(event_type: event_type)
+    subscription = self_serve_subscription(event_type: event_type)
     simulate_invalid_query(subscription)
 
     trigger_event(event_type, uuid: SecureRandom.uuid, company_uuid: SecureRandom.uuid)

data/spec/integration/lib/nulogy_message_bus_producer/{subscriber_graphql_schema_validator_spec.rb → subscriptions/query_validator_spec.rb}

@@ -1,12 +1,12 @@
 require "integration_spec_helper"
 
-RSpec.describe NulogyMessageBusProducer::SubscriberGraphqlSchemaValidator do
+RSpec.describe NulogyMessageBusProducer::Subscriptions::QueryValidator do
   subject(:validator) { described_class.new }
 
   describe "#validate" do
     context "when a valid query is present" do
       it "return true" do
-        subscribe_to(query: <<~GRAPHQL)
+        self_serve_subscription(query: <<~GRAPHQL)
           foo {
             id
           }
@@ -18,7 +18,7 @@ RSpec.describe NulogyMessageBusProducer::SubscriberGraphqlSchemaValidator do
 
     context "when an invalid query is present" do
       let(:subscription_with_error) do
-        subscription = subscribe_to(query: <<~GRAPHQL)
+        subscription = self_serve_subscription(query: <<~GRAPHQL)
           foo {
             id
           }

data/spec/integration/lib/nulogy_message_bus_producer/subscriptions/risky_subscription_blocker_spec.rb

@@ -17,22 +17,6 @@ RSpec.describe NulogyMessageBusProducer::Subscriptions::RiskySubscriptionBlocker
     )
   end
 
-  it "blocks subscriptions which would expand lists" do
-    query = <<~GRAPHQL
-      fooList {
-        id
-      }
-    GRAPHQL
-
-    result = attempt_subscription(query)
-
-    expect(result).to include_json(
-      errors: [{
-        message: "Lists may not be queried:\nfooList"
-      }]
-    )
-  end
-
   def attempt_subscription(query)
     execute_graphql(<<~GRAPHQL, NulogyMessageBusProducer::Specs::TestSchema)
       subscription {