eventflit 0.1.0

data/spec/client_spec.rb

@@ -0,0 +1,629 @@
+require 'spec_helper'
+
+require 'em-http'
+
+describe Eventflit do
+  # The behaviour should be the same when using the Client object, or the
+  # 'global' client delegated through the Eventflit class
+  [lambda { Eventflit }, lambda { Eventflit::Client.new }].each do |client_gen|
+    before :each do
+      @client = client_gen.call
+    end
+
+    describe 'default configuration' do
+      it 'should be preconfigured for api host' do
+        expect(@client.host).to eq('service.eventflit.com')
+      end
+
+      it 'should be preconfigured for port 80' do
+        expect(@client.port).to eq(80)
+      end
+
+      it 'should use standard logger if no other logger if defined' do
+        Eventflit.logger.debug('foo')
+        expect(Eventflit.logger).to be_kind_of(Logger)
+      end
+    end
+
+    describe 'logging configuration' do
+      it "can be configured to use any logger" do
+        logger = double("ALogger")
+        expect(logger).to receive(:debug).with('foo')
+        Eventflit.logger = logger
+        Eventflit.logger.debug('foo')
+        Eventflit.logger = nil
+      end
+    end
+
+    describe "configuration using url" do
+      it "should be possible to configure everything by setting the url" do
+        @client.url = "test://somekey:somesecret@service.eventflit.com:8080/apps/87"
+
+        expect(@client.scheme).to eq('test')
+        expect(@client.host).to eq('service.eventflit.com')
+        expect(@client.port).to eq(8080)
+        expect(@client.key).to eq('somekey')
+        expect(@client.secret).to eq('somesecret')
+        expect(@client.app_id).to eq('87')
+      end
+
+      it "should override scheme and port when setting encrypted=true after url" do
+        @client.url = "http://somekey:somesecret@service.eventflit.com:8080/apps/87"
+        @client.encrypted = true
+
+        expect(@client.scheme).to eq('https')
+        expect(@client.port).to eq(443)
+      end
+
+      it "should fail on bad urls" do
+        expect { @client.url = "gopher/somekey:somesecret@://api.staging.eventflitapp.co://m:8080\apps\87" }.to raise_error(URI::InvalidURIError)
+      end
+
+      it "should raise exception if app_id is not configured" do
+        @client.app_id = nil
+        expect {
+          @client.url
+        }.to raise_error(Eventflit::ConfigurationError)
+      end
+
+    end
+
+    describe 'configuring the cluster' do
+      it 'should set a new default host' do
+        @client.cluster = 'eu'
+        expect(@client.host).to eq('api-eu.eventflit.com')
+      end
+
+      it 'should be overridden by host if it comes after' do
+        @client.cluster = 'eu'
+        @client.host = 'api.staging.eventflit.com'
+        expect(@client.host).to eq('api.staging.eventflit.com')
+      end
+
+      it 'should be overridden by url if it comes after' do
+        @client.cluster = 'eu'
+        @client.url = "http://somekey:somesecret@service.eventflit.com:8080/apps/87"
+
+        expect(@client.host).to eq('service.eventflit.com')
+      end
+
+      it 'should override the url configuration if it comes after' do
+        @client.url = "http://somekey:somesecret@service.eventflit.com:8080/apps/87"
+        @client.cluster = 'eu'
+        expect(@client.host).to eq('api-eu.eventflit.com')
+      end
+
+      it 'should override the host configuration if it comes after' do
+        @client.host = 'api.staging.eventflit.com'
+        @client.cluster = 'eu'
+        expect(@client.host).to eq('api-eu.eventflit.com')
+      end
+    end
+
+    describe 'configuring a http proxy' do
+      it "should be possible to configure everything by setting the http_proxy" do
+        @client.http_proxy = 'http://someuser:somepassword@proxy.host.com:8080'
+
+        expect(@client.proxy).to eq({:scheme => 'http', :host => 'proxy.host.com', :port => 8080, :user => 'someuser', :password => 'somepassword'})
+      end
+    end
+
+    describe 'configuring from env' do
+      after do
+        ENV['EVENTFLIT_URL'] = nil
+      end
+
+      it "works" do
+        url = "http://somekey:somesecret@service.eventflit.com:8080/apps/87"
+        ENV['EVENTFLIT_URL'] = url
+
+        client = Eventflit::Client.from_env
+        expect(client.key).to eq("somekey")
+        expect(client.secret).to eq("somesecret")
+        expect(client.app_id).to eq("87")
+        expect(client.url.to_s).to eq("http://service.eventflit.com:8080/apps/87")
+      end
+    end
+
+    describe 'configuring from url' do
+      it "works" do
+        url = "http://somekey:somesecret@service.eventflit.com:8080/apps/87"
+
+        client = Eventflit::Client.from_url(url)
+        expect(client.key).to eq("somekey")
+        expect(client.secret).to eq("somesecret")
+        expect(client.app_id).to eq("87")
+        expect(client.url.to_s).to eq("http://service.eventflit.com:8080/apps/87")
+      end
+    end
+
+    describe 'when configured' do
+      before :each do
+        @client.app_id = '20'
+        @client.key    = '12345678900000001'
+        @client.secret = '12345678900000001'
+      end
+
+      describe '#[]' do
+        before do
+          @channel = @client['test_channel']
+        end
+
+        it 'should return a channel' do
+          expect(@channel).to be_kind_of(Eventflit::Channel)
+        end
+
+        it "should raise exception if app_id is not configured" do
+          @client.app_id = nil
+          expect {
+            @channel.trigger!('foo', 'bar')
+          }.to raise_error(Eventflit::ConfigurationError)
+        end
+      end
+
+      describe '#channels' do
+        it "should call the correct URL and symbolise response correctly" do
+          api_path = %r{/apps/20/channels}
+          stub_request(:get, api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode('channels' => {
+              "channel1" => {},
+              "channel2" => {}
+            })
+          })
+          expect(@client.channels).to eq({
+            :channels => {
+              "channel1" => {},
+              "channel2" => {}
+            }
+          })
+        end
+      end
+
+      describe '#channel_info' do
+        it "should call correct URL and symbolise response" do
+          api_path = %r{/apps/20/channels/mychannel}
+          stub_request(:get, api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({
+              'occupied' => false,
+            })
+          })
+          expect(@client.channel_info('mychannel')).to eq({
+            :occupied => false,
+          })
+        end
+      end
+
+      describe '#channel_users' do
+        it "should call correct URL and symbolise response" do
+          api_path = %r{/apps/20/channels/mychannel/users}
+          stub_request(:get, api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({
+              'users' => [{ 'id' => 1 }]
+            })
+          })
+          expect(@client.channel_users('mychannel')).to eq({
+            :users => [{ 'id' => 1}]
+          })
+        end
+      end
+
+      describe '#authenticate' do
+        before :each do
+          @custom_data = {:uid => 123, :info => {:name => 'Foo'}}
+        end
+
+        it 'should return a hash with signature including custom data and data as json string' do
+          allow(MultiJson).to receive(:encode).with(@custom_data).and_return 'a json string'
+
+          response = @client.authenticate('test_channel', '1.1', @custom_data)
+
+          expect(response).to eq({
+            :auth => "12345678900000001:#{hmac(@client.secret, "1.1:test_channel:a json string")}",
+            :channel_data => 'a json string'
+          })
+        end
+
+      end
+
+      describe '#trigger' do
+        before :each do
+          @api_path = %r{/apps/20/events}
+          stub_request(:post, @api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({})
+          })
+        end
+
+        it "should call correct URL" do
+          expect(@client.trigger(['mychannel'], 'event', {'some' => 'data'})).
+            to eq({})
+        end
+
+        it "should not allow too many channels" do
+          expect {
+            @client.trigger((0..11).map{|i| 'mychannel#{i}'},
+              'event', {'some' => 'data'}, {
+                :socket_id => "12.34"
+              })}.to raise_error(Eventflit::Error)
+        end
+
+        it "should pass any parameters in the body of the request" do
+          @client.trigger(['mychannel', 'c2'], 'event', {'some' => 'data'}, {
+            :socket_id => "12.34"
+          })
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            parsed = MultiJson.decode(req.body)
+            expect(parsed["name"]).to eq('event')
+            expect(parsed["channels"]).to eq(["mychannel", "c2"])
+            expect(parsed["socket_id"]).to eq('12.34')
+          }
+        end
+
+        it "should convert non string data to JSON before posting" do
+          @client.trigger(['mychannel'], 'event', {'some' => 'data'})
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            expect(MultiJson.decode(req.body)["data"]).to eq('{"some":"data"}')
+          }
+        end
+
+        it "should accept a single channel as well as an array" do
+          @client.trigger('mychannel', 'event', {'some' => 'data'})
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            expect(MultiJson.decode(req.body)["channels"]).to eq(['mychannel'])
+          }
+        end
+
+        %w[app_id key secret].each do |key|
+          it "should fail in missing #{key}" do
+            @client.public_send("#{key}=", nil)
+            expect {
+              @client.trigger('mychannel', 'event', {'some' => 'data'})
+            }.to raise_error(Eventflit::ConfigurationError)
+            expect(WebMock).not_to have_requested(:post, @api_path).with { |req|
+              expect(MultiJson.decode(req.body)["channels"]).to eq(['mychannel'])
+            }
+          end
+        end
+      end
+
+      describe '#trigger_batch' do
+        before :each do
+          @api_path = %r{/apps/20/batch_events}
+          stub_request(:post, @api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({})
+          })
+        end
+
+        it "should call correct URL" do
+          expect(@client.trigger_batch(channel: 'mychannel', name: 'event', data: {'some' => 'data'})).
+            to eq({})
+        end
+
+        it "should convert non string data to JSON before posting" do
+          @client.trigger_batch(
+            {channel: 'mychannel', name: 'event', data: {'some' => 'data'}},
+            {channel: 'mychannel', name: 'event', data: 'already encoded'},
+          )
+          expect(WebMock).to have_requested(:post, @api_path).with { |req|
+            parsed = MultiJson.decode(req.body)
+            expect(parsed).to eq(
+              "batch" => [
+                { "channel" => "mychannel", "name" => "event", "data" => "{\"some\":\"data\"}"},
+                { "channel" => "mychannel", "name" => "event", "data" => "already encoded"}
+              ]
+            )
+          }
+        end
+      end
+
+      describe '#trigger_async' do
+        before :each do
+          @api_path = %r{/apps/20/events}
+          stub_request(:post, @api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({})
+          })
+        end
+
+        it "should call correct URL" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback { |r|
+              expect(r).to eq({})
+              EM.stop
+            }
+          }
+        end
+
+        it "should pass any parameters in the body of the request" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}, {
+              :socket_id => "12.34"
+            }).callback {
+              expect(WebMock).to have_requested(:post, @api_path).with { |req|
+                expect(MultiJson.decode(req.body)["socket_id"]).to eq('12.34')
+              }
+              EM.stop
+            }
+          }
+        end
+
+        it "should convert non string data to JSON before posting" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback {
+              expect(WebMock).to have_requested(:post, @api_path).with { |req|
+                expect(MultiJson.decode(req.body)["data"]).to eq('{"some":"data"}')
+              }
+              EM.stop
+            }
+          }
+        end
+      end
+
+      [:get, :post].each do |verb|
+        describe "##{verb}" do
+          before :each do
+            @url_regexp = %r{service.eventflit.com}
+            stub_request(verb, @url_regexp).
+              to_return(:status => 200, :body => "{}")
+          end
+
+          let(:call_api) { @client.send(verb, '/path') }
+
+          it "should use http by default" do
+            call_api
+            expect(WebMock).to have_requested(verb, %r{http://service.eventflit.com/apps/20/path})
+          end
+
+          it "should use https if configured" do
+            @client.encrypted = true
+            call_api
+            expect(WebMock).to have_requested(verb, %r{https://service.eventflit.com})
+          end
+
+          it "should format the respose hash with symbols at first level" do
+            stub_request(verb, @url_regexp).to_return({
+              :status => 200,
+              :body => MultiJson.encode({'something' => {'a' => 'hash'}})
+            })
+            expect(call_api).to eq({
+              :something => {'a' => 'hash'}
+            })
+          end
+
+          it "should catch all http exceptions and raise a Eventflit::HTTPError wrapping the original error" do
+            stub_request(verb, @url_regexp).to_raise(HTTPClient::TimeoutError)
+
+            error = nil
+            begin
+              call_api
+            rescue => e
+              error = e
+            end
+
+            expect(error.class).to eq(Eventflit::HTTPError)
+            expect(error).to be_kind_of(Eventflit::Error)
+            expect(error.message).to eq('Exception from WebMock (HTTPClient::TimeoutError)')
+            expect(error.original_error.class).to eq(HTTPClient::TimeoutError)
+          end
+
+          it "should raise Eventflit::Error if call returns 400" do
+            stub_request(verb, @url_regexp).to_return({:status => 400})
+            expect { call_api }.to raise_error(Eventflit::Error)
+          end
+
+          it "should raise AuthenticationError if eventflit returns 401" do
+            stub_request(verb, @url_regexp).to_return({:status => 401})
+            expect { call_api }.to raise_error(Eventflit::AuthenticationError)
+          end
+
+          it "should raise Eventflit::Error if eventflit returns 404" do
+            stub_request(verb, @url_regexp).to_return({:status => 404})
+            expect { call_api }.to raise_error(Eventflit::Error, '404 Not found (/apps/20/path)')
+          end
+
+          it "should raise Eventflit::Error if eventflit returns 407" do
+            stub_request(verb, @url_regexp).to_return({:status => 407})
+            expect { call_api }.to raise_error(Eventflit::Error, 'Proxy Authentication Required')
+          end
+
+          it "should raise Eventflit::Error if eventflit returns 500" do
+            stub_request(verb, @url_regexp).to_return({:status => 500, :body => "some error"})
+            expect { call_api }.to raise_error(Eventflit::Error, 'Unknown error (status code 500): some error')
+          end
+        end
+      end
+
+      describe "async calling without eventmachine" do
+        [[:get, :get_async], [:post, :post_async]].each do |verb, method|
+          describe "##{method}" do
+            before :each do
+              @url_regexp = %r{service.eventflit.com}
+              stub_request(verb, @url_regexp).
+                to_return(:status => 200, :body => "{}")
+            end
+
+            let(:call_api) {
+              @client.send(method, '/path').tap { |c|
+                # Allow the async thread (inside httpclient) to run
+                while !c.finished?
+                  sleep 0.01
+                end
+              }
+            }
+
+            it "should use http by default" do
+              call_api
+              expect(WebMock).to have_requested(verb, %r{http://service.eventflit.com/apps/20/path})
+            end
+
+            it "should use https if configured" do
+              @client.encrypted = true
+              call_api
+              expect(WebMock).to have_requested(verb, %r{https://service.eventflit.com})
+            end
+
+            # Note that the raw httpclient connection object is returned and
+            # the response isn't handled (by handle_response) in the normal way.
+            it "should return a httpclient connection object" do
+              connection = call_api
+              expect(connection.finished?).to be_truthy
+              response = connection.pop
+              expect(response.status).to eq(200)
+              expect(response.body.read).to eq("{}")
+            end
+          end
+        end
+      end
+
+      describe "async calling with eventmachine" do
+        [[:get, :get_async], [:post, :post_async]].each do |verb, method|
+          describe "##{method}" do
+            before :each do
+              @url_regexp = %r{service.eventflit.com}
+              stub_request(verb, @url_regexp).
+                to_return(:status => 200, :body => "{}")
+            end
+
+            let(:call_api) { @client.send(method, '/path') }
+
+            it "should use http by default" do
+              EM.run {
+                call_api.callback {
+                  expect(WebMock).to have_requested(verb, %r{http://service.eventflit.com/apps/20/path})
+                  EM.stop
+                }
+              }
+            end
+
+            it "should use https if configured" do
+              EM.run {
+                @client.encrypted = true
+                call_api.callback {
+                  expect(WebMock).to have_requested(verb, %r{https://service.eventflit.com})
+                  EM.stop
+                }
+              }
+            end
+
+            it "should format the respose hash with symbols at first level" do
+              EM.run {
+                stub_request(verb, @url_regexp).to_return({
+                  :status => 200,
+                  :body => MultiJson.encode({'something' => {'a' => 'hash'}})
+                })
+                call_api.callback { |response|
+                  expect(response).to eq({
+                    :something => {'a' => 'hash'}
+                  })
+                  EM.stop
+                }
+              }
+            end
+
+            it "should errback with Eventflit::Error on unsuccessful response" do
+              EM.run {
+                stub_request(verb, @url_regexp).to_return({:status => 400})
+
+                call_api.errback { |e|
+                  expect(e.class).to eq(Eventflit::Error)
+                  EM.stop
+                }.callback {
+                  fail
+                }
+              }
+            end
+          end
+        end
+      end
+    end
+
+    describe "native notifications" do
+      before :each do
+        @client.app_id = "20"
+        @client.key = "testytest"
+        @client.secret = "mysupersecretkey"
+      end
+
+      it "should configure a native notification client using the eventflit client object" do
+        expect(@client.notification_client).to_not be(nil)
+      end
+
+      it "should use the default host if not provided" do
+        expect(@client.notification_host).to eq("push.eventflit.com")
+      end
+
+      it "should use a newly provided host" do
+        @client.notification_host = "test.com"
+        expect(@client.notification_host).to eq("test.com")
+      end
+
+      it "should set the native notification client host to the same one" do
+        expect(@client.notification_host).to eq(@client.notification_client.host)
+      end
+
+      it "should raise an error if no interest is provided" do
+        payload = {
+          gcm: {
+            notification: {
+              title: "Hello",
+              icon: "icon",
+            }
+          }
+        }
+
+        expect { @client.notify([], payload) }.to raise_error(Eventflit::Error)
+      end
+
+      it "should send a request to the notifications endpoint" do
+        notification_host_regexp = %r{push.eventflit.com}
+        payload = {
+          interests: ["test"],
+          gcm: {
+            notification: {
+              title: "Hello",
+              icon: "icon",
+            }
+          }
+        }
+
+        stub_request(
+          :post,
+          notification_host_regexp,
+        ).with(
+          body: MultiJson.encode(payload)
+        ).to_return({
+          :status => 200,
+          :body => MultiJson.encode({ :foo => "bar" })
+        })
+
+        res = @client.notify(["test"], payload)
+        expect(res).to eq({foo: "bar"})
+      end
+    end
+  end
+
+  describe 'configuring cluster' do
+    it 'should allow clients to specify the cluster only with the default host' do
+      client = Eventflit::Client.new({
+        :scheme => 'http',
+        :cluster => 'eu',
+        :port => 80
+      })
+      expect(client.host).to eq('api-eu.eventflit.com')
+    end
+
+    it 'should always have host override any supplied cluster value' do
+      client = Eventflit::Client.new({
+        :scheme => 'http',
+        :host => 'service.eventflit.com',
+        :cluster => 'eu',
+        :port => 80
+      })
+      expect(client.host).to eq('service.eventflit.com')
+    end
+  end
+end