service_template 0.5.0

data/spec/logger/logger_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'service_template/logger/logger'
+
+describe ServiceTemplate::Logger do
+  context '#response' do
+    it 'returns response in the expected format' do
+      response = ServiceTemplate::Logger.response('foo', 'bar', 'baz')
+
+      expect(response[:response][:status]).to eq('foo')
+      expect(response[:response][:headers]).to eq('bar')
+      expect(response[:response][:response]).to eq('baz')
+    end
+  end
+end

data/spec/logger/parseable_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'service_template/logger/parseable'
+
+describe Logging::Layouts::Parseable do
+  context '#format_obj' do
+    it 'formats text as an object' do
+      p = Logging::Layouts::Parseable.new
+      expect(p.format_obj('foobar')).to eq({ text: 'foobar' })
+    end
+
+    it 'does not reformat objects' do
+      p = Logging::Layouts::Parseable.new
+      expect(p.format_obj({ foo: :bar })).to eq({ foo: :bar })
+    end
+  end
+end

data/spec/middleware/authentication_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'service_template/middleware/authentication'
+require 'pry'
+
+describe ServiceTemplate::Identity do
+  before do
+    ENV['HEADER_PASSWORDS'] = 'foo'
+  end
+
+  context 'Authenticated Request' do
+    it 'allows the request to continue if given a correct password header' do
+      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, Array.new] }
+      middleware = ServiceTemplate::Middleware::Authentication.new(app)
+      env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'foo'})
+      status, headers, body = middleware.call(env)
+
+      expect(status).to eq(200)
+    end
+  end
+
+  context 'Failed Authentication Request' do
+    it 'returns an error message if the Password header is not supplied' do
+      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, Array.new] }
+      middleware = ServiceTemplate::Middleware::Authentication.new(app)
+      env = Rack::MockRequest.env_for('/test')
+      status, headers, body = middleware.call(env)
+
+      expect(status).to eq(401)
+      expect(body).to eq([ServiceTemplate::JsonError.new('bad_password', 'bad password').to_json])
+    end
+
+    it 'returns an error message if an incorrect Password header is supplied' do
+      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, Array.new] }
+      middleware = ServiceTemplate::Middleware::Authentication.new(app)
+      env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'incorrect'})
+      status, headers, body = middleware.call(env)
+
+      expect(status).to eq(401)
+      expect(body).to eq([ServiceTemplate::JsonError.new('bad_password', 'bad password').to_json])
+    end
+
+    it 'returns an error message if HEADER_PASSWORDS is not configured' do
+      ENV['HEADER_PASSWORDS'] = nil
+
+      app = lambda { |env| [200, {'Content-Type' => 'application/json'}, Array.new] }
+      middleware = ServiceTemplate::Middleware::Authentication.new(app)
+      env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'incorrect'})
+      status, headers, body = middleware.call(env)
+
+      expect(status).to eq(401)
+      expect(body).to eq([ServiceTemplate::JsonError.new('not_configured', 'password not configured').to_json])
+    end
+  end
+end

data/spec/middleware/database_stats_spec.rb

@@ -0,0 +1,64 @@
+require 'active_record'
+require 'spec_helper'
+require 'service_template/active_record_extensions/stats'
+
+# Delete any prevous instantiations of the emitter and set valid statsd env vars
+ServiceTemplate::Stats.emitter = nil
+ENV['STATSD_HOST'] = 'localhost'
+ENV['STATSD_PORT'] = '8125'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table :foos do |t|
+    t.string :word
+  end
+end
+
+class Foo < ActiveRecord::Base
+end
+
+describe ServiceTemplate::Middleware::DatabaseStats do
+  before do
+    # Delete any prevous instantiations of the emitter and set valid statsd env vars
+    ServiceTemplate::Stats.emitter = nil
+    ENV['STATSD_HOST'] = 'localhost'
+    ENV['STATSD_PORT'] = '8125'
+
+    @foo = Foo.create(word: 'bar')
+  end
+
+  after do
+    middleware = ServiceTemplate::Middleware::DatabaseStats.new(@app)
+    env = Rack::MockRequest.env_for('/test/path')
+    middleware.call(env)
+  end
+
+  it 'should send a query_time for an insert' do
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.table.foos.insert.query_time', an_instance_of(Float))
+
+    @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Foo.create(word: 'baz')] }
+  end
+
+  it 'should send a query_time for a select' do
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.table.foos.select.query_time', an_instance_of(Float))
+
+    @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Foo.first] }
+  end
+
+  it 'should send a query_time for a delete' do
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.table.foos.delete.query_time', an_instance_of(Float))
+
+    @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, @foo.delete ] }
+  end
+
+  it 'should send a query_time for an update' do
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(ServiceTemplate::Stats.emitter).to receive(:timing).with('sql.table.foos.update.query_time', an_instance_of(Float))
+
+    @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, @foo.update_attributes(word: 'baz') ] }
+  end
+end

data/spec/middleware/request_stats_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'service_template/middleware/request_stats'
+
+describe ServiceTemplate::Middleware::RequestStats do
+  before do
+    # Delete any prevous instantiations of the emitter and set valid statsd env vars
+    ServiceTemplate::Stats.emitter = nil
+    ENV['STATSD_HOST'] = 'localhost'
+    ENV['STATSD_PORT'] = '8125'
+  end
+
+  it 'should send the api_response_time' do
+    expect(ServiceTemplate::Stats.emitter).to receive(:timing).with('response_time', an_instance_of(Float))
+    expect(ServiceTemplate::Stats.emitter).to receive(:timing).with('path.get.test.path.response_time', an_instance_of(Float))
+    app = lambda { |env| [200, { 'Content-Type' => 'application/json'}, Array.new] }
+    middleware = ServiceTemplate::Middleware::RequestStats.new(app)
+    env = Rack::MockRequest.env_for('/test/path')
+    middleware.call(env)
+  end
+
+end

data/spec/sortable_api_spec.rb

@@ -0,0 +1,56 @@
+require 'active_record'
+require 'spec_helper'
+require 'service_template/sortable_api'
+
+describe "SortableApi" do
+  describe "#sort_from_params" do
+    before do
+      build_model :foos do
+        integer :param1
+        integer :param2
+      end
+
+      @object1 = Foo.create(param1: 2, param2: 1)
+      @object2 = Foo.create(param1: 2, param2: 3)
+      @object3 = Foo.create(param1: 3, param2: 5)
+      @object4 = Foo.create(param1: 1, param2: 3)
+      @object5 = Foo.create(param1: 1, param2: 1)
+
+      @api = Object.new
+      @api.extend(ServiceTemplate::SortableApi)
+      @foos = Foo.scoped
+    end
+
+    it "returns the sortable objects if sort_param is nil" do
+      expect(@api.sort_from_params(@foos, nil)).to eq(@foos)
+    end
+
+    it "sorts by a given parameter" do
+      sorted = @api.sort_from_params(@foos, "param1")
+      expect(sorted.last).to eq(@object3)
+      expect(sorted.to_sql).to end_with("ORDER BY param1")
+    end
+
+    it "sorts by a given parameter descending if preceded by -" do
+      sorted = @api.sort_from_params(@foos, "-param1")
+      expect(sorted.first).to eq(@object3)
+      expect(sorted.to_sql).to end_with("ORDER BY param1 DESC")
+    end
+
+    it "sorts by multiple parameters in order" do
+      sorted = @api.sort_from_params(@foos, "param2,param1")
+      expect(sorted.to_a).to eq([@object5, @object1, @object4, @object2, @object3])
+      expect(sorted.to_sql).to end_with("ORDER BY param2, param1")
+
+      alt_sorted = @api.sort_from_params(@foos, "param1,param2")
+      expect(alt_sorted.to_a).to eq([@object5, @object4, @object1, @object2, @object3])
+      expect(alt_sorted.to_sql).to end_with("ORDER BY param1, param2")
+    end
+
+    it "sorts by multiple parameters, even if descending" do
+      sorted = @api.sort_from_params(@foos, "-param2,param1")
+      expect(sorted.to_a).to eq([@object3, @object4, @object2, @object5, @object1])
+      expect(sorted.to_sql).to end_with("ORDER BY param2 DESC, param1")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'service_template/setup'
+require 'acts_as_fu'
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+ServiceTemplate.skip_initialization = true
+
+require 'service_template'
+require 'service_template/rspec_extensions/response_helpers'
+
+# from https://gist.github.com/adamstegman/926858
+RSpec.configure do |config|
+  config.include ServiceTemplate::RspecExtensions::ResponseHelpers
+
+  config.before(:all) { silence_output }
+  config.after(:all) { enable_output }
+
+  config.include ActsAsFu
+
+  config.before(:each) do
+    allow(ServiceTemplate).to receive(:initialize)
+    allow(ServiceTemplate::Logger).to receive_message_chain('logger.info').with(:service_template_deprecation_warning)
+  end
+end
+
+# Redirects stderr and stdout to /dev/null.
+def silence_output
+  @orig_stderr = $stderr
+  @orig_stdout = $stdout
+
+  # redirect stderr and stdout to /dev/null
+  $stderr = File.new('/dev/null', 'w')
+  $stdout = File.new('/dev/null', 'w')
+end
+
+# Replace stdout and stderr so anything else is output correctly.
+def enable_output
+  $stderr = @orig_stderr
+  $stdout = @orig_stdout
+  @orig_stderr = nil
+  @orig_stdout = nil
+end

data/spec/stats_d_timer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'service_template/stats_d_timer'
+
+class FooTimer
+  include ServiceTemplate::StatsDTimer
+end
+
+describe ServiceTemplate::StatsDTimer do
+  before do
+    # Delete any prevous instantiations of the emitter
+    ServiceTemplate::Stats.emitter = nil
+    # Stub out logging since there is no log to output to
+    allow(ServiceTemplate::Logger).to receive_message_chain(:logger, :warn)
+  end
+
+  it 'logs a timing event based on how long the block takes' do
+    expect(ServiceTemplate::Stats.emitter).to receive(:timing).with('foo', an_instance_of(Float))
+    FooTimer.report_time('foo') do
+      sleep(0.1)
+    end
+  end
+
+end

data/spec/stats_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'service_template/stats'
+
+describe ServiceTemplate::Stats do
+  before do
+    # Delete any prevous instantiations of the emitter
+    ServiceTemplate::Stats.emitter = nil
+    # Stub out logging since there is no log to output to
+    allow(ServiceTemplate::Logger).to receive_message_chain(:logger, :warn)
+  end
+
+  it 'should log an error if StatsD env variables are not configured' do
+    ENV['STATSD_HOST'] = nil
+    ENV['STATSD_PORT'] = nil
+    message = 'StatsD host and port not configured in environment variables, using default settings'
+    expect(ServiceTemplate::Logger.logger).to receive(:warn).with(message)
+    ServiceTemplate::Stats.emitter
+  end
+
+  it 'should default statsd to localhost port 8125 if env vars are not specified' do
+    ENV['STATSD_HOST'] = nil
+    ENV['STATSD_PORT'] = nil
+    expect(ServiceTemplate::Stats.emitter.host).to eq('127.0.0.1')
+    expect(ServiceTemplate::Stats.emitter.port).to eq(8125)
+  end
+
+  it 'should return a StatsD client object' do
+    expect(ServiceTemplate::Stats.emitter.class.name).to eq('Statsd')
+  end
+
+  it 'the namespace of the StatsD client object should equal the service name' do
+    ENV['SERVICE_NAME'] = 'my-service'
+    expect(ServiceTemplate::Stats.emitter.namespace).to eq("my-service.test")
+  end
+
+  it 'should use env variables to set statsd host and port' do
+    ENV['STATSD_HOST']  = 'localhost'
+    ENV['STATSD_PORT']  = '9000'
+    expect(ServiceTemplate::Stats.emitter.host).to eq('localhost')
+    expect(ServiceTemplate::Stats.emitter.port).to eq('9000')
+  end
+
+  describe '#namespace' do
+    it 'prepends the namespace with the STATSD_API_KEY if present' do
+      ENV['STATSD_API_KEY'] = 'foo'
+      expect(ServiceTemplate::Stats.namespace).to eq("#{ENV['STATSD_API_KEY']}.#{ServiceTemplate::Identity.name}.test")
+    end
+
+    it 'does not include the STATSD_API_KEY if empty' do
+      ENV['STATSD_API_KEY'] = nil
+      expect(ServiceTemplate::Stats.namespace).to eq("#{ServiceTemplate::Identity.name}.test")
+    end
+  end
+
+  describe '#path_to_key' do
+    it 'returns the key string with ids removed and parts joined with dots' do
+      method = 'GET'
+      path = '/foo/123/bar'
+      expect(ServiceTemplate::Stats.path_to_key(method, path)).to eq('get.foo._.bar')
+
+      method = 'POST'
+      path = '/foo'
+      expect(ServiceTemplate::Stats.path_to_key(method, path)).to eq('post.foo')
+    end
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'service_template/version'
+
+describe ServiceTemplate::Version do
+  context '#major_bump' do
+    it 'should set the major revision value, and the rest should be 0' do
+      stub_const('ServiceTemplate::VERSION', '1.2.3')
+      expect(ServiceTemplate::Version.next_major).to eq('2.0.0')
+    end
+
+    it 'should set the major revision value, and the rest should be 0' do
+      stub_const('ServiceTemplate::VERSION', '5.0.0')
+      expect(ServiceTemplate::Version.next_major).to eq('6.0.0')
+    end
+  end
+
+  context '#minor_bump' do
+    it 'should set the minor revision value, leaving the major value unchanged and the patch value to 0' do
+      stub_const('ServiceTemplate::VERSION', '1.2.3')
+      expect(ServiceTemplate::Version.next_minor).to eq('1.3.0')
+    end
+
+    it 'should set the minor revision value, leaving the major value unchanged and the patch value to 0' do
+      stub_const('ServiceTemplate::VERSION', '0.5.0')
+      expect(ServiceTemplate::Version.next_minor).to eq('0.6.0')
+    end
+  end
+
+  context 'patch_bump' do
+    it 'should set the patch revision value, leaving the major and minor values unchanged' do
+      stub_const('ServiceTemplate::VERSION', '1.2.3')
+      expect(ServiceTemplate::Version.next_patch).to eq('1.2.4')
+    end
+
+    it 'should set the patch revision value, leaving the major and minor values unchanged' do
+      stub_const('ServiceTemplate::VERSION', '5.5.5')
+      expect(ServiceTemplate::Version.next_patch).to eq('5.5.6')
+    end
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,9 @@
+desc 'Run the RSpec test suite'
+task :spec do
+  sh *%w[
+    bundle exec
+      rspec --colour
+            --format documentation
+            --fail-fast
+  ]
+end

data/tasks/version.rake

@@ -0,0 +1,51 @@
+desc "bump the gem version"
+namespace :version do
+  namespace :bump do
+
+    task :major do
+      @new_version = ServiceTemplate::Version.next_major
+      execute_version_bump
+    end
+
+    task :minor do
+      @new_version = ServiceTemplate::Version.next_minor
+      execute_version_bump
+    end
+
+    task :patch do
+      @new_version = ServiceTemplate::Version.next_patch
+      execute_version_bump
+    end
+
+    def execute_version_bump
+      if !clean_staging_area?
+        system "git status"
+        raise "Unclean staging area! Be sure to commit or .gitignore everything first. See `git status` above."
+      else
+        require 'git'
+        git = Git.open('.')
+
+        write_update
+        git.add('lib/service_template/version.rb')
+        git.commit("Version bump: #{release_tag}")
+        git.add_tag(release_tag)
+        git.push(git.remote('upstream'), git.branch, release_tag) if git.remote('upstream')
+        puts "Version bumped: #{release_tag}"
+      end
+    end
+
+    def write_update
+      filedata = File.read('lib/service_template/version.rb')
+      changed_filedata = filedata.gsub("VERSION = '#{ServiceTemplate::VERSION}'\n", "VERSION = '#{@new_version}'\n")
+      File.open('lib/service_template/version.rb',"w"){|file| file.puts changed_filedata}
+    end
+
+    def clean_staging_area?
+      `git ls-files --deleted --modified --others --exclude-standard` == ""
+    end
+
+    def release_tag
+      "v#{@new_version}"
+    end
+  end
+end