bandiera-client 2.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 748f5858d09ce6aec023da7987c3f4ab0fc0fa75
+  data.tar.gz: e9cb4b7fa6ba2e12f04b24cb7bc8ca7505b5313a
+SHA512:
+  metadata.gz: 75bbcece7e445f4420c8d4e8bb8091372705e435d4e5d81625ce8cc6d1c02ac71fee56846ded50c5b59360c5c41f5a55aa5f62adc41510914b847e62751f1d60
+  data.tar.gz: e42c294b272343d9a495aa091c90dfcb72bfa7c7d1880f4a6645b8c08404c4befe0be8aeb2e3b4f3c5e26564ab01bdb6a6baddce4f1da8bdd74abdace2b4a6a6

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+artifacts*
+RBENV_VERSION*

data/.hound.yml

@@ -0,0 +1,36 @@
+Metrics/LineLength:
+  Description: 'Limit lines to 120 characters.'
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/AlignHash:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/CollectionMethods:
+  PreferredMethods:
+    collect: 'map'
+    collect!: 'map!'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+Style/DotPosition:
+  EnforcedStyle: leading

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--profile
+

data/.rubocop.yml

@@ -0,0 +1,36 @@
+Metrics/LineLength:
+  Description: 'Limit lines to 120 characters.'
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/AlignHash:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/CollectionMethods:
+  PreferredMethods:
+    collect: 'map'
+    collect!: 'map!'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+Style/DotPosition:
+  EnforcedStyle: leading

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/HISTORY

@@ -0,0 +1,39 @@
+= 2.2.2 / 02-March-2015
+
+  * Handle non-JSON responses correctly (these can happen due to proxy issues etc).
+
+= 2.2.1 / 19-January-2015
+
+  * Small updates for Ruby 2.2.0 compatability.
+  * Documentation updates.
+
+= 2.2.0 / 14-August-2014
+
+  * Add a configurable caching layer into the client.
+  * Expose methods to get raw responses from the Bandiera API
+
+= 2.1.0 / 02-July-2014
+
+  * Switch license to MIT.
+  * Handle connection refused errors.
+
+= 2.0.2 / 15-May-2014
+
+  * Switch the HTTP library used from Typhoeus to RestClient.
+  * Set the default HTTP timeout to 0.2 seconds.
+  * Allow per-request timeout (and other RestClient::Resource options) to be passed through.
+
+= 2.0.1 / 07-May-2014
+
+  * Enable test suite to be run via Rake.
+  * Allow a client name to be passed through in the HTTP headers as 'Bandiera-Client'.
+  * Set the 'User-Agent' HTTP header to identify the requests as coming from this client.
+
+= 2.0.0 / 01-May-2014
+
+  * Update to support Bandiera API v2 and user_groups feature.
+
+= 1.0.0 / 24-Jan-2014
+
+  * Initial tagging of 1.0.0 codebase - support for Bandiera API v1.
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+
+Copyright (c) 2014, Nature Publishing Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# Bandiera::Client (Ruby)
+
+This is a client for talking to the [Bandiera][bandiera] feature flagging
+service from a Ruby application.
+
+This client is compatible with the [v2 Bandiera API][bandiera-api].
+
+**Current Version:** 2.2.1
+**License:** [MIT][mit]
+**Build Status:** [![Build Status][travis-img]][travis]
+
+## Ruby Support:
+
+This client has been tested against the latest MRI and JRuby builds.
+
+# Usage
+
+Add the following to your `Gemfile`:
+
+```ruby
+gem 'bandiera-client'
+```
+
+Then interact with a Bandiera server like so:
+
+```ruby
+require 'bandiera/client'
+
+$bandiera = Bandiera::Client.new('http://bandiera.example.com')
+
+if $bandiera.enabled?('pubserv', 'show-new-search')
+  # show the new experimental search function
+end
+```
+
+The `$bandiera.enabled?` command takes two arguments - the 'feature group',
+and the 'feature name'.  This is because in Bandiera, features are organised
+in groups as it is intented as a service for multiple applications to use at
+the same time - this organisation allows separation of feature flags that are
+intended for different audiences.
+
+## Caching
+
+Bandiera::Client has a small layer of caching built into it in order to:
+
+1. Reduce the amount of HTTP requests made to the Bandiera server
+2. Make things faster
+
+### Strategies
+
+There are three request/caching strategies you can use with Bandiera::Client.
+
+**:single_feature**
+
+This strategy calls the Bandiera API for each new .enabled? request, and stores
+the response in it's local cache. Subsequent `.enabled?` requests (using the
+same arguments) will read from the cache until it has expired.  This is the
+**least** efficient strategy in terms of reducing HTTP requests and speed.
+
+**:group**
+
+This strategy calls the Bandiera API **once** for each feature flag group
+requested, and then stores the resulting feature flag values in the cache.
+This means that all subsequent calls to `.enabled?` for the same group will not
+perform a HTTP request and instead read from the cache until it has expired.
+This is a good compromise in terms of speed and number of HTTP requests, **and
+is the default caching strategy**.
+
+**:all**
+
+This strategy calls the Bandiera API **once** and fetches/caches all feature
+flag values locally. All subsequent calls to `.enabled?` read from the cache
+until it has expired. This strategy is obviously the most efficient in terms of
+the number of HTTP requests if you are requesting flags from across multiple
+groups, but might not be the fastest if there are **lots** of flags in your
+Bandiera instance.
+
+#### Changing the Cache Strategy
+
+```ruby
+$bandiera = Bandiera::Client.new('http://bandiera.example.com')
+$bandiera.cache_strategy = :all
+```
+
+### Cache Expiration
+
+The default cache lifetime is 5 seconds.  If you would like to alter this you
+can do so as follows:
+
+```ruby
+$bandiera = Bandiera::Client.new('http://bandiera.example.com')
+$bandiera.cache_ttl = 10 # 10 seconds
+```
+
+
+# Development
+
+1. Fork this repo.
+2. Run `bundle install`
+
+# License
+
+[© 2014 Nature Publishing Group](LICENSE.txt).
+Bandiera::Client (Ruby) is licensed under the [MIT License][mit].
+
+
+[mit]: http://opensource.org/licenses/mit-license.php
+[bandiera]: https://github.com/nature/bandiera
+[bandiera-api]: https://github.com/nature/bandiera/wiki/API-Documentation
+[travis]: https://travis-ci.org/nature/bandiera-client-ruby
+[travis-img]: https://travis-ci.org/nature/bandiera-client-ruby.svg?branch=master

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bandiera-client.gemspec

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'bandiera/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bandiera-client'
+  spec.version       = Bandiera::Client::VERSION
+  spec.authors       = ['Macmillan Science and Education (New Publsihing Platforms)']
+  spec.email         = ['npp-developers@macmillan.com']
+  spec.description   = 'Bandiera is a simple, stand-alone feature flagging service that is not tied to any existing web framework or language. This is a client for talking to the web service.'
+  spec.summary       = 'Simple feature flagging API client.'
+  spec.homepage      = 'https://github.com/nature/bandiera-client-ruby'
+  spec.license       = 'GPL-3'
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.test_files    = Dir.glob('spec/*_spec.rb')
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
+
+  spec.add_dependency 'rest-client'
+  spec.add_dependency 'moneta'
+  spec.add_dependency 'macmillan-utils'
+end

data/lib/bandiera/client/version.rb

@@ -0,0 +1,5 @@
+module Bandiera
+  class Client
+    VERSION = '2.2.2'
+  end
+end

data/lib/bandiera/client.rb

@@ -0,0 +1,140 @@
+require 'rest_client'
+require 'json'
+require 'logger'
+require 'moneta'
+
+module Bandiera
+  class Client
+    autoload :VERSION, 'bandiera/client/version'
+
+    CACHE_STRATEGIES = [:single_feature, :group, :all]
+
+    attr_accessor :timeout, :client_name, :cache_ttl
+    attr_reader :logger, :cache, :cache_strategy
+
+    def initialize(base_uri = 'http://localhost', logger = Logger.new($stdout), client_name = nil)
+      @base_uri       = base_uri
+      @base_uri       << '/api' unless @base_uri.match(/\/api$/)
+      @logger         = logger
+      @timeout        = 0.2 # 0.4s (0.2 + 0.2) default timeout
+      @client_name    = client_name
+      @cache          = Moneta.new(:LRUHash, expires: true)
+      @cache_ttl      = 5 # 5 seconds
+      @cache_strategy = :group
+    end
+
+    def cache_strategy=(strategy)
+      unless CACHE_STRATEGIES.include?(strategy)
+        raise ArgumentError, "cache_strategy can only be #{CACHE_STRATEGIES}"
+      end
+      @cache_strategy = strategy
+    end
+
+    def enabled?(group, feature, params = {}, http_opts = {})
+      cache_key = build_cache_key(group, feature, params)
+
+      unless cache.key?(cache_key)
+        case cache_strategy
+        when :single_feature then get_feature(group, feature, params, http_opts)
+        when :group          then get_features_for_group(group, params, http_opts)
+        when :all            then get_all
+        end
+      end
+
+      cache.fetch(cache_key)
+    end
+
+    def get_feature(group, feature, params = {}, http_opts = {})
+      path             = "/v2/groups/#{group}/features/#{feature}"
+      default_response = false
+      error_msg_prefix = "[Bandiera::Client#get_feature] '#{group} / #{feature} / #{params}'"
+
+      logger.debug "[Bandiera::Client#get_feature] calling #{path} with params: #{params}"
+
+      get_and_handle_exceptions(path, params, http_opts, default_response, error_msg_prefix) do |value|
+        store_value_in_cache(group, feature, params, value)
+      end
+    end
+
+    def get_features_for_group(group, params = {}, http_opts = {})
+      path             = "/v2/groups/#{group}/features"
+      default_response = {}
+      error_msg_prefix = "[Bandiera::Client#get_features_for_group] '#{group} / #{params}'"
+
+      logger.debug "[Bandiera::Client#get_features_for_group] calling #{path} with params: #{params}"
+
+      get_and_handle_exceptions(path, params, http_opts, default_response, error_msg_prefix) do |feature_hash|
+        store_feature_hash_in_cache(group, params, feature_hash)
+      end
+    end
+
+    def get_all(params = {}, http_opts = {})
+      path             = '/v2/all'
+      default_response = {}
+      error_msg_prefix = "[Bandiera::Client#get_all] '#{params}'"
+
+      logger.debug "[Bandiera::Client#get_all] calling #{path} with params: #{params}"
+
+      get_and_handle_exceptions(path, params, http_opts, default_response, error_msg_prefix) do |group_hash|
+        group_hash.each do |group, feature_hash|
+          store_feature_hash_in_cache(group, params, feature_hash)
+        end
+      end
+    end
+
+    private
+
+    def store_feature_hash_in_cache(group, params, feature_hash)
+      feature_hash.each do |feature, value|
+        store_value_in_cache(group, feature, params, value)
+      end
+    end
+
+    def store_value_in_cache(group, feature, params, value)
+      cache_key = build_cache_key(group, feature, params)
+      cache.store(cache_key, value, expires: cache_ttl)
+    end
+
+    def build_cache_key(group, feature, params)
+      "#{group} / #{feature} / #{params}"
+    end
+
+    def headers
+      headers = { 'User-Agent' => "Bandiera Ruby Client / #{Bandiera::Client::VERSION}" }
+      headers.merge!('Bandiera-Client' => client_name) unless client_name.nil?
+      headers
+    end
+
+    EXCEPTIONS_TO_HANDLE = (
+      Errno.constants.map { |cla| Errno.const_get(cla) } + [RestClient::Exception, JSON::ParserError]
+    ).flatten
+
+    def get_and_handle_exceptions(path, params, http_opts, return_upon_error, error_msg_prefix, &block)
+      res = get(path, params, http_opts)
+      logger.warn "#{error_msg_prefix} - #{res['warning']}" if res['warning']
+      block.call(res['response']) if block
+      res['response']
+    rescue *EXCEPTIONS_TO_HANDLE => error
+      logger.warn("#{error_msg_prefix} - #{error.class} - #{error.message}")
+      return_upon_error
+    end
+
+    def get(path, params, passed_http_opts)
+      default_http_opts = { method: :get, timeout: timeout, open_timeout: timeout, headers: headers }
+      resource          = RestClient::Resource.new(@base_uri, default_http_opts.merge(passed_http_opts))
+      response          = resource[path].get(params: clean_params(params))
+
+      JSON.parse(response.body)
+    end
+
+    def clean_params(passed_params)
+      params = {}
+
+      passed_params.each do |key, val|
+        params[key] = val unless val.nil? || (val.respond_to?(:empty) && val.empty?)
+      end
+
+      params
+    end
+  end
+end

data/spec/lib/bandiera/client_spec.rb

@@ -0,0 +1,472 @@
+require 'spec_helper'
+
+describe Bandiera::Client do
+  let(:base_uri)  { 'http://bandiera.com' }
+  let(:api_uri)   { "#{base_uri}/api" }
+  let(:logger)    { double.as_null_object }
+  subject         { Bandiera::Client.new(api_uri, logger) }
+
+  context 'when a client name is provided' do
+    let(:group)   { 'pubserv' }
+    let(:feature) { 'log-stats' }
+    let(:url)     { "#{api_uri}/v2/groups/#{group}/features" }
+
+    it 'sends it as part of the headers' do
+      stub = stub_api_request(url, { 'response' => {} }, { 'Bandiera-Client' => 'asdf' })
+      client = Bandiera::Client.new(api_uri, logger, 'asdf')
+      client.enabled?(group, feature)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  context 'when some RestClient::Resource options are passed' do
+    it 'passes them onto the RestClient::Resource' do
+      params   = {}
+      options  = { timeout: 24, open_timeout: 24 }
+      response = double(:response, body: JSON.generate({ response: {} }))
+      resource = double(:resource, '[]' => double(get: response))
+
+      expect(RestClient::Resource)
+        .to receive(:new)
+        .with(api_uri, method: :get, timeout: 24, open_timeout: 24, headers: anything)
+        .once
+        .and_return(resource)
+
+      subject.enabled?('foo', 'bar', params, options)
+    end
+  end
+
+  describe '#enabled?' do
+    context 'with cache strategy :single_feature' do
+      before do
+        subject.cache_strategy = :single_feature
+      end
+
+      context 'and an empty cache' do
+        it 'calls #get_feature' do
+          expect(subject).to receive(:get_feature).once
+          subject.enabled?('foo', 'bar')
+        end
+      end
+
+      context 'and a primed cache' do
+        before do
+          cache_key = subject.send(:build_cache_key, 'foo', 'bar', {})
+          subject.cache.store(cache_key, false)
+        end
+
+        it 'does not call #get_feature' do
+          expect(subject).to_not receive(:get_feature)
+          subject.enabled?('foo', 'bar')
+        end
+      end
+    end
+
+    context 'with cache strategy :group' do
+      before do
+        subject.cache_strategy = :group
+      end
+
+      context 'and an empty cache' do
+        it 'calls #get_features_for_group' do
+          expect(subject).to receive(:get_features_for_group).once
+          subject.enabled?('foo', 'bar')
+        end
+      end
+
+      context 'and a primed cache' do
+        before do
+          cache_key = subject.send(:build_cache_key, 'foo', 'bar', {})
+          subject.cache.store(cache_key, false)
+        end
+
+        it 'does not call #get_features_for_group' do
+          expect(subject).to_not receive(:get_features_for_group)
+          subject.enabled?('foo', 'bar')
+        end
+      end
+    end
+
+    context 'with cache strategy :all' do
+      before do
+        subject.cache_strategy = :all
+      end
+
+      context 'and an empty cache' do
+        it 'calls #get_all' do
+          expect(subject).to receive(:get_all).once
+          subject.enabled?('foo', 'bar')
+        end
+      end
+
+      context 'and a primed cache' do
+        before do
+          cache_key = subject.send(:build_cache_key, 'foo', 'bar', {})
+          subject.cache.store(cache_key, false)
+        end
+
+        it 'does not call #get_all' do
+          expect(subject).to_not receive(:get_all)
+          subject.enabled?('foo', 'bar')
+        end
+      end
+    end
+  end
+
+  describe '#get_feature' do
+    let(:group)   { 'pubserv' }
+    let(:feature) { 'log-stats' }
+    let(:url)     { "#{api_uri}/v2/groups/#{group}/features/#{feature}" }
+
+    context 'all is ok' do
+      it 'returns the bandiera response' do
+        stub     = stub_api_request(url, 'response' => true)
+        response = subject.get_feature(group, feature)
+
+        expect(response).to be true
+        expect(stub).to have_been_requested
+      end
+
+      it 'stores the feature value in the cache' do
+        stub_api_request(url, 'response' => true)
+        cache_key = subject.send(:build_cache_key, group, feature, {})
+
+        subject.get_feature(group, feature)
+        expect(subject.cache.key?(cache_key)).to be true
+      end
+
+      context 'and the user has passed through some extra params' do
+        it 'passes them through to the API' do
+          stub = stub_request(:get, url)
+                   .with(query: { user_group: 'admin', user_id: '12345' })
+                   .to_return(
+                     body: JSON.generate('response' => true),
+                     headers: { 'Content-Type' => 'application/json' }
+                   )
+
+          subject.get_feature(group, feature, { user_group: 'admin', user_id: 12345 })
+
+          expect(stub).to have_been_requested
+        end
+      end
+
+      context 'but bandiera returns a warning along with the response' do
+        it 'logs the warning' do
+          stub = stub_api_request(url, 'response' => false, 'warning' => 'The group does not exist')
+
+          expect(logger).to receive(:warn).once
+
+          response = subject.get_feature(group, feature)
+
+          expect(response).to be false
+          expect(stub).to have_been_requested
+        end
+      end
+    end
+
+    context 'bandiera is down' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_feature(group, feature)
+
+        expect(response).to be false
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_feature(group, feature)
+      end
+    end
+
+    context 'bandiera is having some problems' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: 500, body: '')
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_feature(group, feature)
+
+        expect(response).to be false
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: 500, body: '')
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_feature(group, feature)
+      end
+    end
+
+    context 'bandiera times out' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_timeout
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_feature(group, feature)
+
+        expect(response).to be false
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_timeout
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_feature(group, feature)
+      end
+    end
+  end
+
+  describe '#get_features_for_group' do
+    let(:group) { 'pubserv' }
+    let(:url)   { "#{api_uri}/v2/groups/#{group}/features" }
+
+    context 'all is ok' do
+      it 'returns the bandiera response' do
+        feature_hash = { 'show-stuff' => true, 'show-other-stuff' => false }
+        stub         = stub_api_request(url, 'response' => feature_hash)
+        response     = subject.get_features_for_group(group)
+
+        expect(response).to eq(feature_hash)
+        expect(stub).to have_been_requested
+      end
+
+      it 'stores the feature values in the cache' do
+        feature_hash = { 'show-stuff' => true, 'show-other-stuff' => false }
+        stub_api_request(url, 'response' => feature_hash)
+
+        subject.get_features_for_group(group)
+
+        cache_key = subject.send(:build_cache_key, group, 'show-stuff', {})
+        expect(subject.cache.key?(cache_key)).to be true
+
+        cache_key = subject.send(:build_cache_key, group, 'show-other-stuff', {})
+        expect(subject.cache.key?(cache_key)).to be true
+      end
+
+      context 'and the user has passed through some extra params' do
+        it 'passes them through to the API' do
+          stub = stub_request(:get, url)
+                   .with(query: { user_group: 'admin', user_id: '12345' })
+                   .to_return(
+                     body: JSON.generate('response' => {}),
+                     headers: { 'Content-Type' => 'application/json' }
+                   )
+
+          subject.get_features_for_group(group, { user_group: 'admin', user_id: 12345 })
+
+          expect(stub).to have_been_requested
+        end
+      end
+
+      context 'but bandiera returns a warning along with the response' do
+        it 'logs the warning' do
+          stub = stub_api_request(url, 'response' => {}, 'warning' => 'The group does not exist')
+
+          expect(logger).to receive(:warn).once
+
+          response = subject.get_features_for_group(group)
+
+          expect(response).to be {}
+          expect(stub).to have_been_requested
+        end
+      end
+    end
+
+    context 'bandiera is down' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_features_for_group(group)
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_features_for_group(group)
+      end
+    end
+
+    context 'bandiera is having some problems' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: 500, body: '')
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_features_for_group(group)
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: 500, body: '')
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_features_for_group(group)
+      end
+    end
+
+    context 'bandiera times out' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_timeout
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_features_for_group(group)
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_timeout
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_features_for_group(group)
+      end
+    end
+  end
+
+  describe '#get_all' do
+    let(:url) { "#{api_uri}/v2/all" }
+
+    context 'all is ok' do
+      it 'returns the bandiera response' do
+        feature_hash = { 'pubserv' => { 'show-stuff' => true, 'show-other-stuff' => false } }
+        stub         = stub_api_request(url, 'response' => feature_hash)
+        response     = subject.get_all
+
+        expect(response).to eq(feature_hash)
+        expect(stub).to have_been_requested
+      end
+
+      it 'stores the feature values in the cache' do
+        feature_hash = { 'pubserv' => { 'show-stuff' => true, 'show-other-stuff' => false } }
+        stub_api_request(url, 'response' => feature_hash)
+
+        subject.get_all
+
+        cache_key = subject.send(:build_cache_key, 'pubserv', 'show-stuff', {})
+        expect(subject.cache.key?(cache_key)).to be true
+
+        cache_key = subject.send(:build_cache_key, 'pubserv', 'show-other-stuff', {})
+        expect(subject.cache.key?(cache_key)).to be true
+      end
+
+      context 'and the user has passed through some extra params' do
+        it 'passes them through to the API' do
+          stub = stub_request(:get, url)
+                   .with(query: { user_group: 'admin', user_id: '12345' })
+                   .to_return(
+                     body: JSON.generate('response' => {}),
+                     headers: { 'Content-Type' => 'application/json' }
+                   )
+
+          subject.get_all({ user_group: 'admin', user_id: 12345 })
+
+          expect(stub).to have_been_requested
+        end
+      end
+
+      context 'but bandiera returns a warning along with the response' do
+        it 'logs the warning' do
+          stub = stub_api_request(url, 'response' => {}, 'warning' => 'The group does not exist')
+
+          expect(logger).to receive(:warn).once
+
+          response = subject.get_all
+
+          expect(response).to be {}
+          expect(stub).to have_been_requested
+        end
+      end
+    end
+
+    context 'bandiera is down' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_all
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: [0, ''])
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_all
+      end
+    end
+
+    context 'bandiera is having some problems' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_return(status: 200, body: '<html></html>')
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_all
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_return(status: 500, body: '')
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_all
+      end
+    end
+
+    context 'bandiera times out' do
+      it 'returns a default response and logs a warning' do
+        stub_request(:get, url).to_timeout
+
+        expect(logger).to receive(:warn).once
+
+        response = subject.get_all
+
+        expect(response).to be {}
+      end
+
+      it 'does not store anything in the cache' do
+        stub_request(:get, url).to_timeout
+
+        expect(subject.cache).to_not receive(:store)
+
+        subject.get_all
+      end
+    end
+  end
+
+  private
+
+  def stub_api_request(url, response, headers = {})
+    headers.merge! 'User-Agent' => "Bandiera Ruby Client / #{Bandiera::Client::VERSION}"
+    stub_request(:get, url)
+      .with(headers: headers)
+      .to_return(
+        body: JSON.generate(response),
+        headers: { 'Content-Type' => 'application/json' }
+      )
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.join(__FILE__, '../../lib')
+
+require 'bundler'
+Bundler.setup(:default, :test)
+
+ENV['RACK_ENV'] = 'test'
+
+require 'macmillan/utils/rspec/rspec_defaults'
+require 'macmillan/utils/rspec/webmock_helper'
+require 'macmillan/utils/test_helpers/codeclimate_helper'
+require 'macmillan/utils/test_helpers/simplecov_helper'
+require 'pry'
+
+require 'bandiera/client'

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: bandiera-client
+version: !ruby/object:Gem::Version
+  version: 2.2.2
+platform: ruby
+authors:
+- Macmillan Science and Education (New Publsihing Platforms)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: moneta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: macmillan-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Bandiera is a simple, stand-alone feature flagging service that is not
+  tied to any existing web framework or language. This is a client for talking to
+  the web service.
+email:
+- npp-developers@macmillan.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".hound.yml"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- HISTORY
+- LICENSE.txt
+- README.md
+- Rakefile
+- bandiera-client.gemspec
+- lib/bandiera/client.rb
+- lib/bandiera/client/version.rb
+- spec/lib/bandiera/client_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nature/bandiera-client-ruby
+licenses:
+- GPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple feature flagging API client.
+test_files: []
+has_rdoc: