nulogy_message_bus_producer 3.3.0 → 3.4.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

@@ -19,7 +19,7 @@ RSpec.describe NulogyMessageBusProducer::RepopulateReplicationSlots do
     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

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

@@ -2,6 +2,22 @@ require "integration_spec_helper"
 
 RSpec.describe NulogyMessageBusProducer::Subscription do
   context "when validating" do
+    it "is invalid without an id" do
+      model = build_subscription(id: "")
+
+      model.validate
+
+      expect(model.errors[:id]).to contain_exactly("can't be blank")
+    end
+
+    it "is invalid without a subscription_group_id" do
+      model = build_subscription(subscription_group_id: "")
+
+      model.validate
+
+      expect(model.errors[:subscription_group_id]).to contain_exactly("can't be blank")
+    end
+
     it "is invalid with a blank query" do
       model = build_subscription(query: "")
 
@@ -35,7 +51,7 @@ RSpec.describe NulogyMessageBusProducer::Subscription do
 
       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>)"
+        match(/Field 'a_field_that_does_not_exist' doesn't exist on type 'testObject'/)
       )
     end
 
@@ -52,8 +68,10 @@ RSpec.describe NulogyMessageBusProducer::Subscription do
 
   def build_subscription(overrides = {})
     attrs = {
+      id: SecureRandom.uuid,
+      subscription_group_id: SecureRandom.uuid,
       schema_key: "test",
-      query: subscription_query
+      query: subscription_query,
     }.merge(overrides)
 
     NulogyMessageBusProducer::Subscription.new(attrs)

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 {

data/spec/nulogy_message_bus_producer/configuration/query_parser_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+module NulogyMessageBusProducer
+  module Configuration
+    RSpec.describe QueryParser do
+      it "parses queries" do
+        query = <<~QUERY
+          subscription {
+            testCreated(subscriptionId: "abc", subscriptionGroupId: "123", topicName: "test-topic") {
+              foo {
+                id
+              }
+            }
+          }
+        QUERY
+
+        qp = QueryParser.new(query)
+
+        expect(qp.subscription_id).to eq("abc")
+        expect(qp.subscription_group_id).to eq("123")
+        expect(qp.event_type).to eq("testCreated")
+        expect(qp.topic).to eq("test-topic")
+      end
+
+      context "when query is invalid" do
+        it "raises errors for event type" do
+          query = <<~QUERY
+            testCreated(subscriptionId: "abc", subscriptionGroupId: "123", topicName: "test-topic") {
+              foo {
+                id
+              }
+            }
+          QUERY
+
+          qp = QueryParser.new(query)
+
+          expect { qp.event_type }.to raise_error QueryParser::ParseError, /Error extracting event type/
+        end
+
+        it "raises errors for topic" do
+          query = <<~QUERY
+            subscription {
+              testCreated(subscriptionId: "abc", subscriptionGroupId: "123") {
+                foo {
+                  id
+                }
+              }
+            }
+          QUERY
+
+          qp = QueryParser.new(query)
+
+          expect { qp.topic }.to raise_error QueryParser::ParseError, /Error extracting topic/
+        end
+      end
+    end
+  end
+end