vault-tools 0.7.1 → 2.0.2

data/lib/vault-tools/statement_store.rb

@@ -2,8 +2,9 @@ module Vault
   # The StatementStore knows how to save and retrieve invoices from S3
   class StatementStore
     def initialize(opts = {})
-      @key_id = opts.fetch(:key_id, ENV['AWS_ACCESS_KEY_ID'])
-      @key = opts.fetch(:key, ENV['AWS_SECRET_ACCESS_KEY'])
+      @credentials = Aws::Credentials.new(opts.fetch(:key_id, Config[:aws_access_key_id]),
+                                          opts.fetch(:key, Config[:aws_secret_access_key]))
+      @region = opts.fetch(:region, Config[:aws_region])
     end
 
     # Retrieve invoice JSON from S3
@@ -34,20 +35,24 @@ module Vault
 
     # Retrieve the contents in a given format of a given file from S3
     def retrieve(format, opts)
-      s3.buckets[bucket_for(format, opts)].objects[path_for(opts)].read
+      s3.get_object({
+        bucket: bucket_for(format, opts),
+        key: path_for(opts)
+      }).body.read
     end
 
     # Write the contents in the given format to S3
     def write(format, opts)
-      obj = s3.buckets[bucket_for(format, opts)].objects[path_for(opts)]
-      obj.write(opts[:contents])
-      obj
+      s3.put_object({
+        bucket: bucket_for(format, opts),
+        key: path_for(opts),
+        body: opts[:contents]
+      })
     end
 
     # Get an instance of the S3 client to work with
     def s3
-      @s3 ||= AWS::S3.new(access_key_id: @key_id, secret_access_key: @key,
-                          use_ssl: true)
+      @s3 ||= Aws::S3::Client.new(credentials: @credentials, region: @region)
     end
 
     # Determine which bucket an invoice should live in
@@ -73,10 +78,11 @@ module Vault
     private
 
     def validate_path_opts(opts)
+      user = opts[:user_hid] || opts[:user_id]
+
       fail(ArgumentError, 'start_time required!') unless opts[:start_time]
       fail(ArgumentError, 'stop_time required!') unless opts[:stop_time]
       fail(ArgumentError, 'version required!') unless opts[:version]
-      user = opts[:user_hid] || opts[:user_id]
       fail(ArgumentError, 'user_hid or or user_id required!') unless user
     end
   end

data/lib/vault-tools/time.rb

@@ -16,7 +16,7 @@ class Time
   end
 end
 
-class Fixnum
+class Integer
   def weeks
     self.days * 7
   end

data/lib/vault-tools/user.rb

@@ -5,7 +5,7 @@ module Vault
     ID_CAPTURE = /^user(\d+)\@[\w\.]+com$/
     # Convert a user ID into a Heroku user ID.
     #
-    # @param user_id [Fixnum] A user ID.
+    # @param user_id [Integer] A user ID.
     # @return [String] A Heroku ID that uniquely represents the user.
     def self.id_to_hid(user_id)
       "user#{user_id}@heroku.com"
@@ -13,7 +13,7 @@ module Vault
 
     # Convert a user ID into a v5 UUID.
     #
-    # @param user_id [Fixnum] A user ID.
+    # @param user_id [Integer] A user ID.
     # @return [String] A v5 UUID that uniquely represents the user.
     def self.id_to_uuid(user_id)
       url = "https://vault.heroku.com/users/#{user_id}"
@@ -25,7 +25,7 @@ module Vault
     # @param heroku_id [String] A Heroku user ID, such as
     #   `user1234@heroku.com`.
     # @raise [ArgumentError] Raised if a malformed Heroku ID is provided.
-    # @return [Fixnum] The core user ID that uniquely represents the user.
+    # @return [Integer] The core user ID that uniquely represents the user.
     def self.hid_to_id(heroku_id)
       if user_id = heroku_id.slice(ID_CAPTURE, 1)
         user_id.to_i

data/lib/vault-tools/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Vault
   module Tools
-    VERSION = '0.7.1'
+    VERSION = '2.0.2'
   end
 end

data/lib/vault-tools/web.rb

@@ -100,11 +100,19 @@ module Vault
     # Start timing the request.
     before do
       @start_request = Time.now
+      # if client sends content_type: application/json which no longer works
+      # https://github.com/puma/puma/compare/4.3.1...4.3.5#commitcomment-39478516
+      #
+      # fixing this here so that we do not break all client users at once
+      if request.env["CONTENT_TYPE"].nil? && request.env["HTTP_CONTENT_TYPE"]
+        request.env["CONTENT_TYPE"] = request.env["HTTP_CONTENT_TYPE"]
+      end
     end
 
     # Log details about the request including how long it took.
     after do
-      Log.count_status(response.status)
+      @action ||= 'unknown'
+      Log.count_status(response.status, request_path: request.path_info)
       Log.time("http.#{@action}", (Time.now - @start_request) * 1000)
     end
 

data/test/config_test.rb

@@ -9,35 +9,6 @@ class ConfigTest < Vault::TestCase
     Config.reset!
   end
 
-  # Config.remote_env uses the Heroku API to read config vars from
-  # other apps.
-  def test_remote_env
-    api_mock = MiniTest::Mock.new
-    api_response = OpenStruct.new(body: {'DATABASE_URL' => 'postgres:///foo'})
-    Heroku::API.stub(:new, api_mock) do
-      api_mock.expect(:get_config_vars, api_response, ['app'])
-      assert_equal('postgres:///foo',
-                   Config.remote_env('app', 'DATABASE_URL'))
-    end
-  end
-
-  # Config.remote_env uses the Heroku API to read config vars from
-  # other apps.
-  def test_shared_config_loads_shared_with_correct_precedence
-    set_env('CONFIG_APP', 'vault-config')
-    api_mock = MiniTest::Mock.new
-    api_response = OpenStruct.new(body: {'HELLO' => 'world'})
-    Heroku::API.stub(:new, api_mock) do
-      api_mock.expect(:get_config_vars, api_response, ['vault-config'])
-      assert_equal(nil, Config[:hello])
-      Config.default(:hello, 'foo')
-      assert_equal('foo', Config[:hello])
-      # this is how we'll call it in the code
-      Config.load_shared!(Config[:config_app])
-      assert_equal('world', Config[:hello])
-    end
-  end
-
   # Config.env returns the value matching the specified environment
   # variable name.
   def test_env
@@ -55,7 +26,7 @@ class ConfigTest < Vault::TestCase
   # Config.env return nil if an unknown environment variable is
   # requested.
   def test_env_with_unknown_name
-    assert_equal(Config.env('UNKNOWN'), nil)
+    assert_nil(Config.env('UNKNOWN'))
   end
 
   # Config.env! returns the value matching the specified environment
@@ -114,14 +85,14 @@ class ConfigTest < Vault::TestCase
   # variable.
   def test_app_name
     set_env 'APP_NAME', "my-app"
-    Config.app_name.must_equal 'my-app'
+    assert_equal(Config.app_name, 'my-app')
   end
 
   # Config.app_deploy returns the value of the APP_DEPLOY environment
   # variable.
   def test_app_deploy
     set_env 'APP_DEPLOY', "test"
-    Config.app_deploy.must_equal 'test'
+    assert_equal(Config.app_deploy, 'test')
   end
 
   # Config.port raises a RuntimeError if no `PORT` environment variable
@@ -132,7 +103,7 @@ class ConfigTest < Vault::TestCase
     end
   end
 
-  # Config.port converts the value from the environment to a Fixnum
+  # Config.port converts the value from the environment to a Integer
   def test_port_convert_to_int
     set_env 'PORT', "3000"
     assert_equal(3000, Config.port)
@@ -150,14 +121,14 @@ class ConfigTest < Vault::TestCase
 
   # Config.int(VAR) returns nil or VAR as integer.
   def test_int
-    assert_equal(nil, Config.int('FOO'))
+    assert_nil Config.int('FOO')
     set_env 'FOO', "3000"
     assert_equal(3000, Config.int('FOO'))
   end
 
   # Config.time returns nil or VAR as time
   def test_time
-    assert_equal(nil, Config.time('T'))
+    assert_nil(Config.time('T'))
     set_env 'T', '2000'
     assert_equal(Time.utc(2000), Config.time(:t))
     set_env 'T', '2000-2'
@@ -170,7 +141,7 @@ class ConfigTest < Vault::TestCase
 
   # Config.time returns nil or VAR as URI
   def test_uri
-    assert_equal(nil, Config.uri('URL'))
+    assert_nil(Config.uri('URL'))
     set_env 'URL', 'http://user:password@the-web.com/path/to/greatness?foo=bar'
     uri = Config.uri('URL')
     assert_equal('http', uri.scheme)

data/test/defaults_test.rb

@@ -8,13 +8,13 @@ class DefaultsTest < Vault::TestCase
   end
 
   def test_default_when_no_value
-    assert_equal(Config[:max_connections], nil)
+    assert_nil(Config[:max_connections])
     Config.default(:max_connections, 10)
     assert_equal(Config[:max_connections], 10)
   end
 
   def test_default_with_int
-    assert_equal(Config[:max_connections], nil)
+    assert_nil(Config[:max_connections])
     Config.default(:max_connections, '10')
     assert_equal('10', Config[:max_connections])
     assert_equal(10, Config.int(:max_connections))
@@ -23,7 +23,7 @@ class DefaultsTest < Vault::TestCase
   end
 
   def test_default_with_time
-    assert_equal(Config[:date], nil)
+    assert_nil(Config[:date])
     Config.default(:date, '2013-01-01')
     assert_equal('2013-01-01', Config[:date])
     assert_equal(Time.utc(2013), Config.time(:date))
@@ -33,7 +33,7 @@ class DefaultsTest < Vault::TestCase
   end
 
   def test_default_with_array
-    assert_equal(Config[:array], nil)
+    assert_nil(Config[:array])
     Config.default(:array, '10')
     assert_equal('10', Config[:array])
     assert_equal(['10'], Config.array(:array))

data/test/helper.rb

@@ -1,8 +1,11 @@
 require 'vault-test-tools'
 require 'vault-tools'
 require 'rr'
+require 'minitest/around/unit'
+require 'pry'
 
 ENV['RACK_ENV'] = 'test'
+ENV['AWS_REGION'] = 'us-east-1'
 
 module LoggedDataHelper
   def logged_data
@@ -39,69 +42,32 @@ class Vault::TestCase
 end
 
 module StubbedS3
-  class FakeFile
-    def initialize(contents=nil)
-      @contents = contents
-    end
-
-    def write(contents)
-      @contents = contents
-    end
-
-    def read
-      @contents
-    end
-  end
-
-  class FakeBucket
-    def initialize
-      @files = {}
-    end
-
-    def [](file_name)
-      @files[file_name] ||= FakeFile.new
-    end
-
-    def write(file_name, contents)
-      @files[file_name].write(contents)
-    end
-
-    def objects
-      self
-    end
-  end
-
   class FakeClient
     def initialize
-      @buckets = {}
+      @files = {}
     end
 
-    def [](bucket_name)
-      @buckets[bucket_name] ||= FakeBucket.new
+    def put_object(opts)
+      @files["#{opts[:bucket]}::#{opts[:key]}"] = opts[:body]
     end
 
-    def buckets
-      self
+    def get_object(opts)
+      val = @files["#{opts[:bucket]}::#{opts[:key]}"]
+      OpenStruct.new(body: OpenStruct.new(read: val))
     end
   end
 
   class << self
     def seed(bucket, file, contents)
-      fake_client.buckets[bucket].objects[file].write(contents)
+      fake_client.put_object({bucket: bucket, key: file, body: contents})
     end
 
     def fake_client
       @client ||= FakeClient.new
     end
 
-    def enable!(env, opts={})
-      AWS.stub!
-      expected_aws_args = {
-        access_key_id: opts.fetch(:access_key_id, 'FAKE_ID'),
-        secret_access_key: opts.fetch(:secret_access_key, 'FAKE_KEY'),
-        use_ssl: opts.fetch(:use_ssl, true)
-      }
-      env.stub(AWS::S3).new(expected_aws_args) { fake_client }
+    def enable!(opts={}, &block)
+      Aws::S3::Client.stub(:new, fake_client) { yield }
     end
   end
 end

data/test/log_test.rb

@@ -31,10 +31,11 @@ class LogTest < Vault::TestCase
 
   # Vault::Log.count_status emits metrics to measure HTTP responses.
   def test_count_status
-    Vault::Log.count_status(201)
-    assert_equal '1', logged_data['count#test-app.http.201']
-    assert_equal '1', logged_data['count#test-app.http.2xx']
-    assert_equal 'test-deploy', logged_data['source']
+    Vault::Log.count_status(201, request_path: '/some/request/path')
+    assert_equal 1, logdata['count#test-app.http.201']
+    assert_equal 1, logdata['count#test-app.http.2xx']
+    assert_equal '/some/request/path', logdata['request_path']
+    assert_equal 'test-deploy', logdata['source']
   end
 
   def test_measure

data/test/s3_test.rb

@@ -7,13 +7,14 @@ end
 class S3Test < Vault::TestCase
   include LoggedDataHelper
 
-  def setup
-    super
+  def around
     set_env 'APP_DEPLOY', 'test'
     set_env 'AWS_ACCESS_KEY_ID', 'fake access key id'
     set_env 'AWS_SECRET_ACCESS_KEY', 'fake secret access key'
-    AWS.stub!
-    @consumer = SomeS3Consumer.new
+    StubbedS3.enable! do
+      @consumer = SomeS3Consumer.new
+      yield
+    end
   end
 
   def log_output
@@ -23,33 +24,32 @@ class S3Test < Vault::TestCase
   # S3 writes should be logged.
   def test_write_logs
     @consumer.write('fake bucket', 'fake key', 'fake value')
-    assert_match /fake key/, log_output
+    assert_match(/fake key/, log_output)
   end
 
   # S3 reads should be logged.
   def test_read_logs
     @consumer.read('fake bucket', 'fake key')
-    assert_match /fake key/, log_output
+    assert_match(/fake key/, log_output)
   end
 
   # Should use S3 to write to bucket
   def test_writes_to_s3_bucket
-    mock(@consumer).s3.mock!.buckets.
-      mock!.[]('fake bucket').
-      mock!.objects.
-      mock!.[]('fake key').
-      mock!.write('fake value')
+    mock(@consumer).s3.mock!.put_object({
+      bucket: 'fake bucket',
+      key: 'fake key',
+      body: 'fake value'
+    })
     @consumer.write('fake bucket', 'fake key', 'fake value')
   end
 
   # Should use S3 to read from bucket
   def test_reads_from_s3_bucket
       #s3.buckets[bucket].objects[key].read
-    mock(@consumer).s3.mock!.buckets.
-      mock!.[]('fake bucket').
-      mock!.objects.
-      mock!.[]('fake key').
-      mock!.read
+    mock(@consumer).s3.mock!.get_object({
+      bucket: 'fake bucket',
+      key: 'fake key'
+    }).mock!.body.mock!.read
     @consumer.read('fake bucket', 'fake key')
   end
 end

data/test/statement_store_test.rb

@@ -1,12 +1,12 @@
 require 'helper'
 
 class StatementStoreTest < Vault::TestCase
-  def setup
-    super
-    StubbedS3.enable!(self)
-    StubbedS3.seed('vault-v2-json-invoice-test',
-                   '2014-10-01/2014-11-01/user8@heroku.com_v2', '{"foo": 1}')
-
+  def around(&block)
+    StubbedS3.enable! do
+      StubbedS3.seed('vault-v2-json-invoice-test',
+                     '2014-10-01/2014-11-01/user8@heroku.com_v2', '{"foo": 1}')
+      yield
+    end
   end
 
   def test_invoice_path_with_user_id
@@ -36,15 +36,12 @@ class StatementStoreTest < Vault::TestCase
     # Nothing Before Write
     doc = inv.get_json(start_time: '2014-10-01', stop_time: '2014-11-01',
                        user_hid: 'user9@heroku.com', version: 2)
-    expected = nil
-    assert_equal expected, doc
+    assert_nil doc
 
     # Write to S3 updating expectation
     expected = {"bar" => 3}
-    obj = inv.write_json(start_time: '2014-10-01', stop_time: '2014-11-01',
-                         user_hid: 'user9@heroku.com', version: 2,
-                         contents: expected)
-    assert obj.is_a? StubbedS3::FakeFile
+    inv.write_json(start_time: '2014-10-01', stop_time: '2014-11-01',
+                   user_hid: 'user9@heroku.com', version: 2, contents: expected)
 
     # There after write
     doc = inv.get_json(start_time: '2014-10-01', stop_time: '2014-11-01',