bima-shark-sdk 2.3.0

data/lib/shark/rspec/fake_consent_service/request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeConsentService
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def stub_requests
+          WebMock.stub_request(:post, %r{^#{host}/consents}).to_return do |request|
+            log_info "[Shark][ConsentService] Faking POST request with body: #{request.body}"
+
+            payload_data = JSON.parse(request.body)['data']
+            object_data = ObjectCache.instance.add(payload_data)
+
+            SharkSpec.fake_response(200, data: object_data)
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/consents/.+}).to_return do |request|
+            log_info '[Shark][ConsentService] Faking GET request'
+
+            id = request.uri.path.split('/')[2]
+
+            object_data = ObjectCache.instance.objects.detect do |object|
+              object['id'] == id
+            end
+
+            if object_data.present?
+              SharkSpec.fake_response(200, data: object_data)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+        end
+
+        def host
+          Shark.configuration.consent_service.site
+        end
+
+        def log_info(message)
+          Shark.logger.info message
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_consent_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'fake_consent_service/object_cache'
+require_relative 'fake_consent_service/request'
+
+module Shark
+  module RSpec
+    module FakeConsentService
+      def self.setup
+        ObjectCache.clear
+        Request.setup
+      end
+
+      def self.reset
+        ObjectCache.clear
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_contact_service/object_cache.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Shark
+  module RSpec
+    module FakeContactService
+      class ObjectCache
+        include Singleton
+        include Helpers::CacheHelper
+
+        attr_accessor :objects
+
+        def initialize
+          @objects = []
+        end
+
+        def self.clear
+          instance.objects = []
+        end
+
+        def add(object)
+          unless object['attributes'].keys.include?('avatar_url')
+            avatar_url = "https://contactservice/path/to/avatar/#{object['id']}.png"
+            object['attributes']['avatar_url'] = avatar_url
+          end
+
+          objects.push(object)
+
+          object
+        end
+
+        def objects_contain(type, params)
+          filtered_objects = []
+          filter = params['filter']
+
+          if filter['contact_id']
+            filtered_objects = objects.select do |object|
+              return false unless object['type'] == type
+
+              ids = (object['attributes']['contact_ids'] || []).map(&:to_s)
+              ids.include?(filter.values.first)
+            end
+          end
+          filtered_objects
+        end
+
+        def search_objects(type, params)
+          filtered_objects = []
+          filters = params['filter'] && params['filter']['filter']
+          condition, filter = filters.first
+
+          if condition.present? && filter.present?
+            filtered_objects = objects.select do |object|
+              return false unless object['type'] == type
+
+              attribute_key, value = filter.first
+              attribute = object['attributes'][attribute_key]
+
+              case condition
+              when 'contains_word_prefixes'
+                attribute.to_s.start_with?(value)
+              when 'contains_words'
+                words = case value
+                        when Array
+                          value
+                        when Hash
+                          value.keys
+                          # else
+                          #   value.split(",").map(&:strip)
+                        end
+                words.include?(attribute.to_s)
+              when 'equals'
+                attribute.to_s == value
+              when 'is_blank'
+                attribute.blank?
+              when 'is_true'
+                attribute == true
+              else
+                false
+              end
+            end
+          end
+
+          filtered_objects
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_contact_service/request.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeContactService
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def stub_requests
+          cache = FakeContactService::ObjectCache.instance
+
+          WebMock.stub_request(:post, %r{^#{host}/.*}).to_return do |request|
+            log_info "[Shark][ContactService] Faking POST request with body: #{request.body}"
+            log_info request.uri.to_s
+
+            id = SecureRandom.uuid
+            parsed_data = JSON.parse(request.body)['data']
+            parsed_data['id'] = id
+
+            cache.add(parsed_data)
+            SharkSpec.fake_response(201, data: parsed_data)
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/.*$}).to_return do |request|
+            log_info '[Shark][ContactService] Faking GET request'
+            log_info request.uri.to_s
+
+            type = request.uri.path.split('/')[2]
+            params = query_params_to_object(request.uri)
+
+            objects = if %w[contacts accounts].include?(type) && params['filter'].present?
+                        cache.search_objects(type, params)
+                      elsif %w[activities].include?(type) && params['filter'].present?
+                        cache.objects_contain(type, params)
+                      else
+                        cache.objects.select do |object|
+                          object['type'] == type
+                        end
+                      end
+
+            SharkSpec.fake_response(200, data: objects)
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/.+/.+}).to_return do |request|
+            log_info '[Shark][ContactService] Faking GET request with ID'
+            log_info request.uri.to_s
+
+            type = request.uri.path.split('/')[2]
+            id = request.uri.path.split('/')[3]
+            query = request.uri.query_values
+
+            object = cache.find(type, id)
+
+            if object.present?
+              body = { data: object }
+
+              if query && query['include']
+                relation_name = query['include']
+                included_objects = cache.included_resources(object, query)
+
+                if included_objects.empty?
+                  object['relationships'] ||= { relation_name => { data: [] } }
+                end
+                body = {
+                  data: object,
+                  included: included_objects
+                }
+              end
+
+              SharkSpec.fake_response(200, body)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/groups/.+/memberships}).to_return do |request|
+            log_info '[Shark][ContactService] Faking GET memberships request'
+            log_info request.uri.to_s
+
+            type = request.uri.path.split('/')[2]
+            group_id = request.uri.path.split('/')[3]
+            contact_id = query_params_to_object(request.uri)['filter']['contact_id']
+
+            group = cache.find(type, group_id)
+
+            if group.present?
+              contacts = group.dig('relationships', 'contacts', 'data')
+
+              if contacts.present?
+                if contacts.detect { |c| c['type'] == 'contacts' && c['id'] == contact_id }
+                  next SharkSpec.fake_response(200, {})
+                end
+              end
+            end
+
+            SharkSpec.fake_response(404, errors: [])
+          end
+
+          WebMock.stub_request(:patch, %r{^#{host}/.*/.+}).to_return do |request|
+            log_info "[Shark][ContactService] Faking PATCH request with body: #{request.body}"
+            log_info request.uri.to_s
+
+            type = request.uri.path.split('/')[2]
+            id = request.uri.path.split('/')[3]
+            parsed_data = JSON.parse(request.body)['data']
+
+            object = cache.find(type, id)
+
+            if object.present?
+              (parsed_data['attributes'] || {}).each do |key, value|
+                object['attributes'] = {} if object['attributes'].blank?
+                object['attributes'][key] = value
+              end
+
+              (parsed_data['relationships'] || {}).each do |key, value|
+                object['relationships'] = {} if object['relationships'].blank?
+                object['relationships'][key] = value
+              end
+
+              SharkSpec.fake_response(200, data: object)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+
+          WebMock.stub_request(:delete, %r{^#{host}/.*/.+}).to_return do |request|
+            log_info '[Shark][ContactService] Faking DELETE request'
+            log_info request.uri.to_s
+
+            type = request.uri.path.split('/')[2]
+            id = request.uri.path.split('/')[3]
+
+            object = cache.find(type, id)
+
+            if object.present?
+              cache.objects.delete(object)
+
+              SharkSpec.fake_response(204, nil)
+            else
+              SharkSpec.fake_response(404, errors: [])
+            end
+          end
+        end
+
+        def host
+          Shark.configuration.contact_service.site
+        end
+
+        def log_info(message)
+          Shark.logger.info message
+        end
+
+        def query_params_to_object(request_uri)
+          uri = URI.parse(request_uri)
+          return {} if uri.query.blank?
+
+          query = uri.query.gsub(/%5B[0-9]%5D/, '%5B%5D')
+          Rack::Utils.parse_nested_query(query)
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_contact_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'fake_contact_service/object_cache'
+require_relative 'fake_contact_service/request'
+
+module Shark
+  module RSpec
+    module FakeContactService
+      def self.setup
+        ObjectCache.clear
+        Request.setup
+      end
+
+      def self.reset
+        ObjectCache.clear
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_double_opt_in/object_cache.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Shark
+  module RSpec
+    module FakeDoubleOptIn
+      class ObjectCache
+        include Singleton
+        attr_accessor :objects
+
+        def initialize
+          @objects = {}
+        end
+
+        def self.clear
+          instance.objects = {}
+        end
+
+        def add_execution(attributes)
+          verification_token = SecureRandom.uuid
+
+          objects[verification_token] = {
+            'id' => verification_token,
+            'attributes' => attributes,
+            'type' => 'executions'
+          }
+
+          objects[verification_token]
+        end
+
+        def find_execution(verification_token)
+          objects[verification_token]
+        end
+
+        def remove_execution(verification_token)
+          objects.delete(verification_token)
+        end
+
+        def create_request(attributes)
+          timeout = attributes['timeout'] || 3600
+          leeway_to_terminate = attributes['leeway_to_terminate'] || 3600
+
+          verification_expires_at = Time.now.to_i + timeout.to_i
+          execution_expires_at = verification_expires_at + leeway_to_terminate.to_i
+
+          add_execution({
+                          'payload' => attributes['payload'],
+                          'request_type' => attributes['request_type'],
+                          'max_verifications' => attributes['max_verifications'] || 10,
+                          'verifications_count' => 0,
+                          'verification_expires_at' => verification_expires_at,
+                          'execution_expires_at' => execution_expires_at
+                        })
+
+          attributes
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_double_opt_in/request.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeDoubleOptIn
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def stub_requests
+          WebMock.stub_request(:post, %r{^#{host}/requests}).to_return do |request|
+            log_info "Faking POST request with body: #{request.body}"
+
+            data = JSON.parse(request.body)['data']
+            attributes = data['attributes'] || {}
+
+            ObjectCache.instance.create_request(attributes)
+
+            fake_response(200, {
+                            data: {
+                              id: SecureRandom.uuid,
+                              attributes: attributes,
+                              type: 'requests'
+                            }
+                          })
+          end
+
+          WebMock.stub_request(:post, %r{^#{host}/executions/.+/verify}).to_return do |request|
+            log_info 'Faking POST request'
+
+            verification_token = request.uri.path.split('/').reverse[1]
+            object = ObjectCache.instance.find_execution(verification_token)
+
+            if verification_token_invalid?(object)
+              fake_response(404, { errors: [] })
+            else
+              verification_expires_at = object['attributes']['verification_expires_at']
+              max_verifications = object['attributes']['max_verifications']
+              verifications_count = object['attributes']['verifications_count']
+
+              is_verification_expired = Time.now.to_i > verification_expires_at
+              is_number_of_requests_exceeded = max_verifications <= verifications_count
+
+              if is_verification_expired
+                errors = [{ code: 'verification_expired' }]
+                fake_response(422, { errors: errors })
+              elsif is_number_of_requests_exceeded
+                errors = [{ code: 'exceeded_number_of_verification_requests' }]
+                fake_response(422, { errors: errors })
+              else
+                fake_response(200, { data: object })
+              end
+            end
+          end
+
+          WebMock.stub_request(:get, %r{^#{host}/executions/.+}).to_return do |request|
+            log_info 'Faking GET request'
+
+            verification_token = request.uri.path.split('/').reverse[0]
+            object = ObjectCache.instance.find_execution(verification_token)
+
+            if verification_token_invalid?(object)
+              fake_response(404, { errors: [] })
+            else
+              attributes = object['attributes']
+
+              if attributes['verifications_count'].zero?
+                fake_response(422, { errors: [{ code: 'requested_unverified_execution' }] })
+              else
+                fake_response(200, { data: object })
+              end
+            end
+          end
+
+          WebMock.stub_request(:delete, %r{^#{host}/executions/.+}).to_return do |request|
+            log_info 'Faking DELETE request'
+
+            verification_token = request.uri.path.split('/').reverse[0]
+            object = ObjectCache.instance.find_execution(verification_token)
+
+            if verification_token_invalid?(object)
+              fake_response(404, { errors: [] })
+            else
+              ObjectCache.instance.remove_execution(verification_token)
+              fake_response(200, { data: object })
+            end
+          end
+        end
+
+        def verification_token_invalid?(object)
+          return true  if object.blank?
+
+          execution_expires_at = object['attributes']['execution_expires_at']
+          verification_expires_at = object['attributes']['verification_expires_at']
+          verifications_count = object['attributes']['verifications_count']
+
+          is_execution_time_expired = Time.now.to_i > execution_expires_at
+          is_verification_expired = Time.now.to_i > verification_expires_at
+          has_verification_been_verified = verifications_count.positive?
+
+          return true  if is_execution_time_expired
+          return true  if is_verification_expired && !has_verification_been_verified
+
+          false
+        end
+
+        def fake_response(status, body)
+          {
+            headers: {
+              content_type: 'application/vnd.api+json'
+            },
+            status: status,
+            body: body.is_a?(String) ? body : body.to_json
+          }
+        end
+
+        def host
+          Shark.configuration.double_opt_in.site
+        end
+
+        def log_info(message)
+          Shark.logger.info "[Shark][DoubleOptInService] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_double_opt_in.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'fake_double_opt_in/object_cache'
+require_relative 'fake_double_opt_in/request'
+
+module Shark
+  module RSpec
+    module FakeDoubleOptIn
+      def self.setup
+        ObjectCache.clear
+        Request.setup
+      end
+
+      def self.reset
+        ObjectCache.clear
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_mailing_service/request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeMailingService
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def stub_requests
+          WebMock.stub_request(:post, %r{^#{host}/mails}).to_return do |request|
+            log_info "[Shark][MailingService] Faking POST request with body: #{request.body}"
+
+            id = SecureRandom.uuid
+            payload_data = JSON.parse(request.body)['data']
+
+            SharkSpec.fake_response(201, data: {
+                                      type: 'mails',
+                                      id: id,
+                                      attributes: payload_data
+                                    })
+          end
+        end
+
+        def host
+          Shark.configuration.mailing_service.site
+        end
+
+        def log_info(message)
+          message
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_mailing_service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'fake_mailing_service/request'
+
+module Shark
+  module RSpec
+    module FakeMailingService
+      def self.setup
+        Request.setup
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_notification_service/request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+
+module Shark
+  module RSpec
+    module FakeNotificationService
+      class Request
+        include Singleton
+
+        def self.setup
+          instance = self.instance
+          instance.stub_requests
+        end
+
+        def stub_requests
+          WebMock.stub_request(
+            :post,
+            %r{^#{host}/notifications/bulk_creation}
+          ).to_return do |request|
+            log_info "Faking POST bulk creation request with body: #{request.body}"
+
+            SharkSpec.fake_response(201, data: {
+                                      type: 'notifications',
+                                      id: '12345678-1234-1234-1234-1234567890ab'
+                                    })
+          end
+
+          WebMock.stub_request(:post, %r{^#{host}/notifications}).to_return do |request|
+            log_info "Faking POST request with body: #{request.body}"
+
+            id = SecureRandom.uuid
+            payload_data = JSON.parse(request.body)['data']
+
+            SharkSpec.fake_response(201, data: {
+                                      type: 'notifications',
+                                      id: id,
+                                      attributes: payload_data
+                                    })
+          end
+        end
+
+        def host
+          Shark.configuration.notification_service.site
+        end
+
+        def log_info(message)
+          Shark.logger.info "[Shark][NotificationService] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/shark/rspec/fake_notification_service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'fake_notification_service/request'
+
+module Shark
+  module RSpec
+    module FakeNotificationService
+      def self.setup
+        Request.setup
+      end
+    end
+  end
+end