grape-slack-bot 1.5.0 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f8fc51cbef0f57cb132347ce71c02fba8ca5130749cca04ed3ffdbefb482ce1
-  data.tar.gz: a1a96768a308005a8bf8aa709c3c3a29f927c31a624c4ad9bfc6d7e60b9b01ad
+  metadata.gz: '049b94a107e222f8e3662dc34cacef51262a1d50e4d0945bcad042a507352218'
+  data.tar.gz: 30e9fe036b313632de57ce8ea17ddf496569115dbeebf993d2c7d24bd34c7c19
 SHA512:
-  metadata.gz: 2d372b748e6242a8766799b762afbfb205023491cb5c1fb6f453cc2454d389d89eecfb0e3f7257ef92b545b3215e579103c325dcc5ba0a40bb5a48f6ab4451d3
-  data.tar.gz: 2c72725ce9911a95c74ae015e6f24aa77eae793afd97b7c2d5c934598c3c9195c61bd386bdd40661b2ce3d89bd875e426ed926c3ec711f709090ed2e591ffaf8
+  metadata.gz: 882f712999c11d787a68ff23b8c9c9a675191f4d95c56700fd06fb5020d11e23b39b532d364e511619d9976d63055e5365669994d596d1f370c51bc93c6d806c
+  data.tar.gz: 13fb5097d19007d8c907ccc59267c8b5f4d1c80878b58f665c8c8f5759677fdeafaa32160cb936a466e3b12b25cac6dce5be5cd3179a29b2414db3a3f24f0cdc

data/lib/slack_bot/callback.rb

@@ -3,27 +3,34 @@ require 'active_support/core_ext/numeric/time'
 
 module SlackBot
   class Callback
-    CALLBACK_CACHE_KEY = "slack-bot-callback".freeze
+    CALLBACK_KEY_PREFIX = "slack-bot-callback".freeze
     CALLBACK_RECORD_EXPIRES_IN = 15.minutes.freeze
 
-    def self.find(id, config: nil)
+    def self.find(id, user: nil, config: nil)
       return if id.blank?
 
-      callback = new(id: id, config: config)
+      callback = new(id: id, user: user, config: config)
       callback.reload
     rescue SlackBot::Errors::CallbackNotFound
       nil
     end
 
-    def self.create(class_name:, user:, channel_id: nil, config: nil, payload: nil, expires_in: nil)
+    def self.create(class_name:, user:, channel_id: nil, config: nil, payload: nil, expires_in: nil, user_scope: nil)
       callback =
-        new(class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in)
+        new(class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in, user_scope: user_scope)
       callback.save
       callback
     end
 
-    attr_reader :id, :data, :args, :config, :expires_in
-    def initialize(id: nil, class_name: nil, user: nil, channel_id: nil, payload: nil, config: nil, expires_in: nil)
+    def self.find_or_create(id:, class_name:, user:, channel_id: nil, config: nil, payload: nil, expires_in: nil, user_scope: nil)
+      callback = find(id, user: user, config: config)
+      return callback if callback.present?
+
+      create(class_name: class_name, user: user, channel_id: channel_id, payload: payload, config: config, expires_in: expires_in, user_scope: user_scope)
+    end
+
+    attr_reader :id, :data, :args, :config, :expires_in, :user_scope
+    def initialize(id: nil, class_name: nil, user: nil, channel_id: nil, payload: nil, config: nil, expires_in: nil, user_scope: nil)
       @id = id
       @data = {
         class_name: class_name,
@@ -34,6 +41,7 @@ module SlackBot
       @args = SlackBot::Args.new
       @config = config || SlackBot::Config.current_instance
       @expires_in = expires_in || CALLBACK_RECORD_EXPIRES_IN
+      @user_scope = user_scope.nil? ? true : user_scope
     end
 
     def reload
@@ -121,20 +129,30 @@ module SlackBot
     end
 
     def generate_id
-      SecureRandom.uuid
+      SecureRandom.hex(10)
+    end
+
+    def storage_key
+      if user_scope
+        raise "User is required for scoped callback" if user.blank?
+
+        "#{CALLBACK_KEY_PREFIX}:u#{user.id}:#{id}"
+      else
+        "#{CALLBACK_KEY_PREFIX}:#{id}"
+      end
     end
 
     def read_data
-      config.callback_storage_instance.read("#{CALLBACK_CACHE_KEY}:#{id}")
+      config.callback_storage_instance.read(storage_key)
     end
 
     def write_data(data, expires_in: nil)
       expires_in ||= CALLBACK_RECORD_EXPIRES_IN
-      config.callback_storage_instance.write("#{CALLBACK_CACHE_KEY}:#{id}", data, expires_in: expires_in)
+      config.callback_storage_instance.write(storage_key, data, expires_in: expires_in)
     end
 
     def delete_data
-      config.callback_storage_instance.delete("#{CALLBACK_CACHE_KEY}:#{id}")
+      config.callback_storage_instance.delete(storage_key)
     end
   end
 end

data/lib/slack_bot/event.rb

@@ -4,7 +4,8 @@ module SlackBot
       define_singleton_method(:view_klass) { klass }
     end
 
-    attr_reader :current_user, :params, :callback, :config
+    attr_reader :current_user, :params, :config
+    attr_accessor :callback
     def initialize(current_user: nil, params: nil, callback: nil, config: nil)
       @current_user = current_user
       @params = params
@@ -28,6 +29,7 @@ module SlackBot
         self.class.view_klass
           .new(current_user: current_user, params: params, context: context)
           .send(view_method_name)
+      view = view.merge(callback_id: callback.id) if callback.present?
       response =
         SlackBot::ApiClient.new.views_publish(user_id: user_id, view: view)
 

data/lib/slack_bot.rb

@@ -22,5 +22,5 @@ require 'slack_bot/pager'
 require 'slack_bot/grape_extension'
 
 module SlackBot
-  VERSION = '1.5.0'.freeze
+  VERSION = '1.5.2'.freeze
 end

data/spec/slack_bot/callback_spec.rb

@@ -26,173 +26,115 @@ describe SlackBot::Callback do
   let(:callback_id) { "test_callback_id" }
 
   describe ".find" do
-    subject(:find) { described_class.find(callback_id, config: config) }
+    subject(:find) { described_class.find(callback_id, user: user, config: config) }
 
-    before do
-      allow(callback_storage_instance).to receive(:read).with("slack-bot-callback:test_callback_id").and_return(data)
-    end
-
-    context "when callback is found" do
-      let(:data) { { class_name: "Test", user_id: 1, channel_id: "test_channel_id", payload: { test: "test" }, args: "" } }
-
-      it "returns callback" do
-        expect(find).to be_a(described_class)
-        expect(find.id).to eq(callback_id)
-        expect(find.class_name).to eq("Test")
-        expect(find.user).to eq(user)
-        expect(find.user_id).to eq(1)
-        expect(find.channel_id).to eq("test_channel_id")
-        expect(find.payload).to eq({ test: "test" })
-      end
-    end
-
-    context "when callback is not found" do
-      let(:data) { nil }
-
-      it "returns nil" do
-        expect(find).to eq(nil)
-      end
-    end
-  end
-
-  describe ".create" do
-    subject(:create) { described_class.create(class_name: "Test", user: user, channel_id: "test_channel_id", config: config) }
-
-    before do
-      allow_any_instance_of(described_class).to receive(:generate_id).and_return("test_callback_id")
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
-        class_name: "Test",
-        user_id: 1,
-        channel_id: "test_channel_id",
-        payload: nil
-      }, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN)
-    end
-
-    let(:data) { { class_name: "Test", user_id: 1, channel_id: "test_channel_id", payload: nil } }
-
-    it "returns callback" do
-      expect(create).to be_a(described_class)
-      expect(create.id).to eq("test_callback_id")
-      expect(create.class_name).to eq("Test")
-      expect(create.user).to eq(user)
-      expect(create.user_id).to eq(1)
-      expect(create.channel_id).to eq("test_channel_id")
-      expect(create.payload).to eq(nil)
-    end
-  end
-
-  describe "#reload" do
-    subject(:reload) { callback.reload }
-    let(:callback) {
-      described_class.new(id: "test_callback_id", config: config)
-    }
-    let(:data) {
+    let(:cached_data) {
       {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        payload: { test: "test payload" },
-        args: ""
+        payload: { test: "test" },
+        args: "test"
       }
     }
 
     before do
-      allow(callback_storage_instance).to receive(:read).with("slack-bot-callback:test_callback_id").and_return(data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
 
     it "returns callback" do
-      expect(reload).to be_a(described_class)
-      expect(reload.id).to eq("test_callback_id")
-      expect(reload.class_name).to eq("Test")
-      expect(reload.user).to eq(user)
-      expect(reload.user_id).to eq(1)
-      expect(reload.channel_id).to eq("test_channel_id")
-      expect(reload.payload).to eq({ test: "test payload" })
+      expect(find).to be_a(described_class)
+      expect(find.id).to eq(callback_id)
+      expect(find.class_name).to eq("Test")
+      expect(find.user).to eq(user)
+      expect(find.channel_id).to eq("test_channel_id")
+      expect(find.payload).to eq({ test: "test" })
+      expect(find.args).to be_a(SlackBot::Args)
     end
 
     context "when callback is not found" do
-      let(:data) { nil }
+      let(:cached_data) { nil }
 
-      it "raises error" do
-        expect { reload }.to raise_error(SlackBot::Errors::CallbackNotFound)
+      it "returns nil" do
+        expect(find).to be_nil
       end
     end
   end
 
-  describe "#save" do
-    subject(:save) { callback.save }
-    let(:callback) {
-      described_class.new(
+  describe ".create" do
+    subject(:create) {
+      described_class.create(
         class_name: "Test",
         user: user,
         channel_id: "test_channel_id",
-        payload: { test: "test payload" },
+        payload: { test: "test" },
         config: config
       )
     }
 
-    before do
-      allow_any_instance_of(described_class).to receive(:generate_id).and_return("test_callback_id")
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
+    let(:cached_data) {
+      {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        payload: { test: "test payload" }
-      }, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN)
+        payload: { test: "test" },
+        args: ""
+      }
+    }
+
+    before do
+      allow_any_instance_of(described_class).to receive(:generate_id).and_return(callback_id)
+      allow(callback_storage_instance).to receive(:write).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}", cached_data, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN).and_return(cached_data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
 
-    it "returns callback" do
-      save
-      expect(callback).to be_a(described_class)
-      expect(callback.id).to eq("test_callback_id")
-      expect(callback.args).to be_a(SlackBot::Args)
+    it "creates callback" do
+      expect(create).to be_a(described_class)
+      expect(create.id).to be_present
+      expect(create.class_name).to eq("Test")
+      expect(create.user).to eq(user)
+      expect(create.channel_id).to eq("test_channel_id")
+      expect(create.payload).to eq({ test: "test" })
+      expect(create.args).to be_a(SlackBot::Args)
     end
   end
 
-  describe "#update" do
-    subject(:update) { callback.update(payload) }
-    let(:callback) {
-      described_class.new(
-        id: "test_callback_id",
+  describe ".find_or_create" do
+    subject(:find_or_create) {
+      described_class.find_or_create(
+        id: callback_id,
         class_name: "Test",
         user: user,
         channel_id: "test_channel_id",
-        payload: { test: "test payload" },
+        payload: { test: "test" },
         config: config
       )
     }
 
-    before do
-      allow(callback_storage_instance).to receive(:write).with("slack-bot-callback:test_callback_id", {
-        args: "",
+    let(:cached_data) {
+      {
         class_name: "Test",
-        user_id: 1,
+        user_id: user.id,
         channel_id: "test_channel_id",
-        payload: { test: "test payload 2" }
-      }, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN)
-    end
-
-    let(:payload) { { test: "test payload 2" } }
+        payload: { test: "test" },
+        args: ""
+      }
+    }
 
-    it "returns callback" do
-      update
-      expect(callback).to be_a(described_class)
-      expect(callback.id).to eq("test_callback_id")
-      expect(callback.args).to be_a(SlackBot::Args)
+    before do
+      allow_any_instance_of(described_class).to receive(:generate_id).and_return(callback_id)
+      allow(callback_storage_instance).to receive(:write).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}", cached_data, expires_in: SlackBot::Callback::CALLBACK_RECORD_EXPIRES_IN).and_return(cached_data)
+      allow(callback_storage_instance).to receive(:read).with("#{SlackBot::Callback::CALLBACK_KEY_PREFIX}:u#{user.id}:#{callback_id}").and_return(cached_data)
     end
-  end
-
-  describe "#destroy" do
-
-  end
-
-  describe "#user" do
-
-  end
-
-  describe "#handler_class" do
 
+    it "finds or creates callback" do
+      expect(find_or_create).to be_a(described_class)
+      expect(find_or_create.id).to eq(callback_id)
+      expect(find_or_create.class_name).to eq("Test")
+      expect(find_or_create.user).to eq(user)
+      expect(find_or_create.channel_id).to eq("test_channel_id")
+      expect(find_or_create.payload).to eq({ test: "test" })
+      expect(find_or_create.args).to be_a(SlackBot::Args)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape-slack-bot
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.2
 platform: ruby
 authors:
 - Andrei Makarov