sxs 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93243c7fda169668829a419181bbe7136e24ebbc9eb245108182995899abde7b
-  data.tar.gz: f4e9b2f8eeb6c5f397405ad8badd7cd61a04e32f44ac9cc7625799c2bcf14f66
+  metadata.gz: bfa20059cae54bb1425872b0ae8acc51acbc7666c9c3ae755a2746247271ed3d
+  data.tar.gz: f2558d38acc7d575503c5f383bc307d01d610c61e893b8c29c567f87cb27af3e
 SHA512:
-  metadata.gz: 45059b39c7cf5f1ff0ccfd7e8526544c38934dd14cf5a6d20172e232d18a217691a4b4f6c764ff5165a5083999977d8139bca0bfafa5ec979c265ac77c1b8c7d
-  data.tar.gz: d28d6de75c87dd17f251a8bf2a92da6f0f41acac2a65a2eaa4c5b58e7a8a127ad209e03c47378c8e2cc4bf737f03f3a1a325c4323f11acc03765886f32f1b81a
+  metadata.gz: 3ff293454db87415920ec4a06d6715f3ca0d71d5f125f1078f7a156fb74a80f1905311e1832983617d193ea1b94f5c00e830664f64347d5566e5b0aa448f85c3
+  data.tar.gz: 57291c8906e3583919286f6a829b1aec5f1ef62fab78fa623c6dee2fe334a6b56ef8d6b13876388cb5530366c7ffc7a46b3d9128f1cb7e6b57187f9cf698ace1

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## v0.2.0
+
+### Updates
+
+- `provider` key now is mandatory;
+- `provider` is only used on `production`;
+- `provider` is auto setted by `redis` on `development` and `memory` on `test`;
+- You can override auto set using env `SXS_PROVIDER` that overwrites `provider` on production too;
+
 ## v0.1.0
 
 ### News

data/README.md

@@ -30,10 +30,11 @@ SXS::Publisher.new('some_key', provider: :redis).publish({ body: 'value' }.to_js
 SXS::Publisher.new('some_key', provider: :memory).publish({ body: 'value' }.to_json)
 ```
 
-If you do not specify the `provider` you will get:
+On `development` and `test` environment `provider` be overwrited for the following:
 
 ```ruby
 development: :redis
-production: ArgumentError
 test: :memory
 ```
+
+To avoid this ovewrite you can specify the provider via ENV `SXS_PROVIDER`. This will overwrites `production` too.

data/lib/sxs/publisher.rb

@@ -2,7 +2,7 @@
 
 module SXS
   class Publisher
-    def initialize(queue_url, provider: nil)
+    def initialize(queue_url, provider:)
       @provider  = provider
       @queue_url = queue_url
     end
@@ -21,18 +21,26 @@ module SXS
       SXS::Publishers::Memory
     end
 
-    def publisher
-      @publisher ||= provider.new(@queue_url)
+    def provider
+      return provider_select(ENV['SXS_PROVIDER']) unless ENV['SXS_PROVIDER'].nil?
+
+      return provider_select(@provider) if environment == 'production'
+
+      { 'development' => redis, 'test' => memory }[environment]
     end
 
-    def provider
-      return { memory: memory, redis: redis, sqs: sqs }[@provider.to_sym] if @provider
+    def provider_select(name)
+      value = { memory: memory, redis: redis, sqs: sqs }[name&.to_sym]
 
-      if environment == 'production'
-        raise ArgumentError, 'missing provider: redis, sqs, sns or memory'
+      if value.nil?
+        raise ArgumentError, 'Missing provider! Availables: :memory, :redis, :sns or :sqs'
       end
 
-      { 'development' => redis, 'test' => memory }[environment]
+      value
+    end
+
+    def publisher
+      @publisher ||= provider.new(@queue_url)
     end
 
     def redis

data/lib/sxs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SXS
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/sxs/publisher/publish_spec.rb

@@ -6,96 +6,344 @@ RSpec.describe SXS::Publisher, '#publish' do
   let!(:body) { { key: 'value' }.to_json }
   let!(:queue_url) { 'queue_url' }
 
-  context 'when provider is given' do
-    context 'when provider is sqs' do
-      let(:provider) { :sqs }
+  after do
+    ENV['RAILS_ENV'] = 'test'
 
-      let!(:sqs) { instance_spy 'SXS::Publishers::SQS' }
+    ENV.delete 'SXS_PROVIDER'
+  end
 
-      before do
-        allow(SXS::Publishers::SQS).to receive(:new).with(queue_url).and_return sqs
+  context 'when provider is sqs' do
+    let(:provider) { :sqs }
+
+    context 'when rails env is development' do
+      before { ENV['RAILS_ENV'] = 'development' }
+
+      context 'when sxs provider is not setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+        end
+
+        it 'overwrites with redis' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
       end
 
-      it 'publishes the message' do
-        publisher.publish body
+      context 'when sxs provider is setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+
+          ENV['SXS_PROVIDER'] = 'memory'
+        end
 
-        expect(sqs).to have_received(:publish).with(body)
+        it 'is used' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
       end
     end
 
-    context 'when provider is redis' do
-      let(:provider) { :redis }
+    context 'when rails env is production' do
+      before { ENV['RAILS_ENV'] = 'production' }
 
-      let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+      context 'when sxs provider is not setted' do
+        let!(:sqs) { instance_spy 'SXS::Publishers::SQS' }
 
-      before do
-        allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+        before do
+          allow(SXS::Publishers::SQS).to receive(:new).with(queue_url).and_return sqs
+        end
+
+        it 'uses the given provider' do
+          publisher.publish body
+
+          expect(sqs).to have_received(:publish).with(body)
+        end
       end
 
-      it 'publishes the message' do
-        publisher.publish body
+      context 'when sxs provider is setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
 
-        expect(redis).to have_received(:publish).with(body)
+          ENV['SXS_PROVIDER'] = 'redis'
+        end
+
+        it 'is used' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
       end
     end
 
-    context 'when provider is memory' do
-      let(:provider) { :memory }
+    context 'when rails env is test' do
+      before { ENV['RAILS_ENV'] = 'test' }
+
+      context 'when sxs provider is not setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
 
-      let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        end
 
-      before do
-        allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        it 'overwrites with memory' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
       end
 
-      it 'publishes the message' do
-        publisher.publish body
+      context 'when sxs provider is setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+
+          ENV['SXS_PROVIDER'] = 'redis'
+        end
+
+        it 'is used' do
+          publisher.publish body
 
-        expect(memory).to have_received(:publish).with(body)
+          expect(redis).to have_received(:publish).with(body)
+        end
       end
     end
   end
 
-  context 'when provider is not given' do
-    let(:provider) { nil }
+  context 'when provider is redis' do
+    let(:provider) { :redis }
 
     context 'when rails env is development' do
-      let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+      before { ENV['RAILS_ENV'] = 'development' }
 
-      before do
-        allow(ENV).to receive(:[]).with('RAILS_ENV').and_return 'development'
-        allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+      context 'when sxs provider is not setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+        end
+
+        it 'overwrites with redis' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
       end
 
-      it 'publishes the message on redis' do
-        publisher.publish body
+      context 'when sxs provider is setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+
+          ENV['SXS_PROVIDER'] = 'memory'
+        end
 
-        expect(redis).to have_received(:publish).with(body)
+        it 'is used' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
       end
     end
 
     context 'when rails env is production' do
-      let!(:error) { 'missing provider: redis, sqs, sns or memory' }
+      before { ENV['RAILS_ENV'] = 'production' }
+
+      context 'when sxs provider is not setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+        end
+
+        it 'uses the given provider' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
+      end
 
-      before { allow(ENV).to receive(:[]).with('RAILS_ENV').and_return 'production' }
+      context 'when sxs provider is setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
 
-      it 'raises' do
-        expect { publisher.publish body }.to raise_error ArgumentError, error
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+
+          ENV['SXS_PROVIDER'] = 'memory'
+        end
+
+        it 'is used' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
       end
     end
 
     context 'when rails env is test' do
-      let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+      before do
+        ENV['RAILS_ENV'] = 'test'
+      end
+
+      after do
+        ENV['RAILS_ENV'] = 'test'
+      end
+
+      context 'when sxs provider is not setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        end
+
+        it 'overwrites with memory' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
+      end
 
+      context 'when sxs provider is setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        end
+
+        before do
+          ENV['SXS_PROVIDER'] = 'memory'
+        end
+
+        after do
+          ENV.delete 'SXS_PROVIDER'
+        end
+
+        it 'is used' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
+      end
+    end
+  end
+
+  context 'when provider is memory' do
+    let(:provider) { :memory }
+
+    context 'when rails env is development' do
       before do
-        allow(ENV).to receive(:[]).with('RAILS_ENV').and_return 'test'
-        allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        ENV['RAILS_ENV'] = 'development'
+      end
+
+      after do
+        ENV['RAILS_ENV'] = 'test'
       end
 
-      it 'publishes the message on memory' do
-        publisher.publish body
+      context 'when sxs provider is not setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+        end
+
+        it 'overwrites with redis' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
+      end
+
+      context 'when sxs provider is setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+
+          ENV['SXS_PROVIDER'] = 'redis'
+        end
+
+        it 'is used' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
+      end
+    end
+
+    context 'when rails env is production' do
+      before { ENV['RAILS_ENV'] = 'production' }
+
+      context 'when sxs provider is not setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        end
+
+        it 'uses the given provider' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
+      end
+
+      context 'when sxs provider is setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+
+          ENV['SXS_PROVIDER'] = 'redis'
+        end
+
+        it 'is used' do
+          publisher.publish body
+
+          expect(redis).to have_received(:publish).with(body)
+        end
+      end
+    end
+
+    context 'when rails env is test' do
+      before { ENV['RAILS_ENV'] = 'test' }
+
+      context 'when sxs provider is not setted' do
+        let!(:memory) { instance_spy 'SXS::Publishers::Memory' }
+
+        before do
+          allow(SXS::Publishers::Memory).to receive(:new).with(queue_url).and_return memory
+        end
+
+        it 'overwrites with memory' do
+          publisher.publish body
+
+          expect(memory).to have_received(:publish).with(body)
+        end
+      end
+
+      context 'when sxs provider is setted' do
+        let!(:redis) { instance_spy 'SXS::Publishers::Redis' }
+
+        before do
+          allow(SXS::Publishers::Redis).to receive(:new).with(queue_url).and_return redis
+
+          ENV['SXS_PROVIDER'] = 'redis'
+        end
+
+        it 'is used' do
+          publisher.publish body
 
-        expect(memory).to have_received(:publish).with(body)
+          expect(redis).to have_received(:publish).with(body)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sxs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Washington Botelho
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-sns
@@ -122,7 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: SNS/SQS wrapper to make `development` (Redis) and `test` (Memory) environment
+description: SNS/SQS wrapper to make development (Redis) and test (Memory) environment
   transparent.
 email: wbotelhos@gmail.com
 executables: []