service_template 0.5.0

data/spec/generators/migration_generator_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'service_template/generators/migration_generator'
+require 'service_template/cli'
+
+describe ServiceTemplate::Generators::MigrationGenerator do
+
+  let(:migration_filename) { 'foo' }
+  let(:test_migrations_directory) { 'spec/tmp' }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:output_directory).and_return(test_migrations_directory)
+    allow_any_instance_of(described_class).to receive(:migration_filename).and_return(migration_filename)
+  end
+
+  after do
+    FileUtils.rm_rf(test_migrations_directory)
+  end
+
+  describe 'AddFooToBar flew:string:index brew:integer' do
+    before do
+      ServiceTemplate::CLI::Base.new.generate("migration", 'AddFooToBar', 'flew:string:index', 'brew:integer')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class AddFooToBar/)
+    end
+
+    it 'adds the columns' do
+      expect(@migration_code).to match(/add_column :bars, :flew, :string/)
+      expect(@migration_code).to match(/add_column :bars, :brew, :integer/)
+    end
+
+    it 'adds the index on the correct column' do
+      expect(@migration_code).to match(/add_index :bars, :flew/)
+    end
+  end
+
+  describe 'RemoveFooFromBar flew:string brew:integer' do
+    before do
+      ServiceTemplate::CLI::Base.new.generate("migration", 'RemoveFooFromBar', 'flew:string', 'brew:integer')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class RemoveFooFromBar/)
+    end
+
+    it 'removes the columns' do
+      expect(@migration_code).to match(/remove_column :bars, :flew, :string/)
+      expect(@migration_code).to match(/remove_column :bars, :brew, :integer/)
+    end
+  end
+
+  describe 'CreateJoinTableFooBar foo bar' do
+    before do
+      ServiceTemplate::CLI::Base.new.generate("migration", 'CreateJoinTableFooBar', 'foo', 'bar')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class CreateJoinTableFooBar/)
+    end
+
+    it 'creates the join table' do
+      expect(@migration_code).to match(/create_join_table :foos, :bars/)
+    end
+
+    it 'adds placeholders for the indexing' do
+      expect(@migration_code).to match(/# t.index \[:foo_id, :bar_id\]/)
+      expect(@migration_code).to match(/# t.index \[:bar_id, :foo_id\]/)
+    end
+  end
+
+  describe 'CreateSkrillex drops:integer hair:string:index' do
+    before do
+      ServiceTemplate::CLI::Base.new.generate("migration", 'CreateSkrillex', 'drops:integer', 'hair:string:index')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class CreateSkrillex/)
+    end
+
+    it 'creates the table' do
+      expect(@migration_code).to match(/create_table :skrillexes/)
+    end
+
+    it 'adds the columns' do
+      expect(@migration_code).to match(/t.integer :drops/)
+      expect(@migration_code).to match(/t.string :hair/)
+    end
+
+    it 'adds the index on the correct column' do
+      expect(@migration_code).to match(/add_index :skrillexes, :hair/)
+    end
+  end
+
+  describe
+
+end

data/spec/generators/readme_generator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'service_template/generators/readme_generator'
+require 'service_template/cli'
+
+describe ServiceTemplate::Generators::ReadmeGenerator do
+  let(:test_readme_directory) { 'spec/tmp' }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:output_directory).and_return(test_readme_directory)
+    ServiceTemplate::CLI::Base.new.generate("readme")
+  end
+
+  after do
+    FileUtils.rm_rf(test_readme_directory)
+  end
+
+  describe 'README' do
+    it 'creates a README in the current directory' do
+      expected_readme_file = File.join(test_readme_directory, 'README.md')
+      readme = File.read(expected_readme_file)
+
+      expect(readme).to match /# #{ServiceTemplate::Identity.name}/
+    end
+  end
+
+  describe 'spec' do
+    it 'creates a README spec' do
+      expected_spec_file = File.join(test_readme_directory, 'spec/docs/readme_spec.rb')
+      spec_code = File.read(expected_spec_file)
+
+      expect(spec_code).to match(/describe \'README\'/)
+    end
+  end
+
+end

data/spec/generators/scaffold_generator_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'service_template/generators/scaffold_generator'
+require 'service_template/cli'
+
+describe ServiceTemplate::Generators::ScaffoldGenerator do
+  let(:app_name) { 'my_test_app' }
+  let(:app_path) { 'spec/my_different_directory' }
+  let(:options) { {} }
+
+  before do
+    scaffold = ServiceTemplate::CLI::Base.new(args, options)
+    scaffold.invoke(:new)
+  end
+
+  after do
+    if args[1] # if app_path exists, delete dir at app_path
+      FileUtils.rm_rf(args[1])
+    else # otherwise delete dir at app_name
+      FileUtils.rm_rf(args[0])
+    end
+  end
+
+  context 'given only an app name' do
+    let(:args) { [app_name] }
+
+    it 'creates a scaffold app in a directory that mirrors the app name' do
+      args = [app_name]
+      expect(Dir).to exist(app_name)
+    end
+  end
+
+  context 'given an app name and a directory' do
+    let(:args) { [app_name, app_path] }
+
+    it 'creates a scaffold app in a directory of my choosing' do
+      expect(Dir).to exist(app_path)
+    end
+
+    it 'creates a .env file with with a development database name' do
+      expect(File).to exist("#{app_path}/.env")
+      env_file = File.read("#{app_path}/.env")
+      expect(env_file).to match(/#{app_name}_development/)
+    end
+
+    it 'creates a .env.test file with a test database name' do
+      expect(File).to exist("#{app_path}/.env.test")
+      env_test_file = File.read("#{app_path}/.env.test")
+      expect(env_test_file).to match(/#{app_name}_test/)
+    end
+
+    it 'selects mysql as the default database adapter' do
+      database_config_file = File.read("#{app_path}/config/database.yml")
+      expect(database_config_file).to match(/adapter: mysql2/)
+    end
+
+    it 'adds the mysql2 gem in the Gemfile' do
+      gemfile = File.read("#{app_path}/Gemfile")
+      expect(gemfile).to match(/gem 'mysql2'/)
+    end
+
+    it 'generates an application api' do
+      expect(File).to exist("#{app_path}/app/apis/application_api.rb")
+    end
+
+    it 'the application API inherits from Grape::API' do
+      application_api_file = File.read("#{app_path}/app/apis/application_api.rb")
+      expect(application_api_file).to match(/class ApplicationApi < Grape::API/)
+    end
+
+    it 'generates an example API and spec' do
+      expect(File).to exist("#{app_path}/app/apis/hello_api.rb")
+      expect(File).to exist("#{app_path}/spec/apis/hello_api_spec.rb")
+    end
+  end
+
+  context 'with the -d=pg option' do
+    let(:args) { [app_name, app_path] }
+    let(:options) { { :database => "pg" } }
+
+    it 'selects postres/pg as the database' do
+      database_config_file = File.read("#{app_path}/config/database.yml")
+      expect(database_config_file).to match(/adapter: postgresql/)
+    end
+
+    it 'adds the pg gem in the Gemfile' do
+      gemfile = File.read("#{app_path}/Gemfile")
+      expect(gemfile).to match(/gem 'pg'/)
+    end
+  end
+end

data/spec/grape_extenders_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe ServiceTemplate::GrapeExtenders do
+  include Rack::Test::Methods
+
+  before do
+    allow(ServiceTemplate::Logger.logger).to receive(:debug)
+  end
+
+  subject do
+    Class.new(Grape::API) do
+      format :json
+      extend ServiceTemplate::GrapeExtenders
+    end
+  end
+
+  def app
+    subject
+  end
+
+  describe 'ActiveRecord extensions' do
+    it 'rescues ActiveRecord::RecordNotFound and returns a 404' do
+      subject.get do
+        raise ActiveRecord::RecordNotFound
+      end
+
+      get '/'
+      expect(response_code).to be 404
+      expect(parsed_response.error.code).to eq 'record_not_found'
+    end
+  end
+
+  describe 'AASM extensions' do
+    it 'rescues AASM::InvalidTransition and returns a 422' do
+      module AASM
+        class InvalidTransition < StandardError
+        end
+      end
+
+      subject.get do
+        raise AASM::InvalidTransition
+      end
+
+      get '/'
+      expect(response_code).to be 422
+      expect(parsed_response.error.code).to eq 'unprocessable_entity'
+    end
+  end
+end

data/spec/grape_extensions/error_formatter_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'service_template/grape_extensions/error_formatter'
+
+describe Grape::ErrorFormatter::Json do
+  context '#call' do
+    it 'returns an api_error for plain error messages' do
+      error = Grape::ErrorFormatter::Json.call('test message', nil)
+      parsed = JSON.parse(error)
+      expect(parsed['error']['code']).to eq('api_error')
+      expect(parsed['error']['message']).to eq('test message')
+    end
+
+    it 'returns a specified error when given a ServiceTemplate::JsonError object' do
+      json_error = ServiceTemplate::JsonError.new(:foo, 'bar')
+      error = Grape::ErrorFormatter::Json.call(json_error, nil)
+      parsed = JSON.parse(error)
+      expect(parsed['error']['code']).to eq('foo')
+      expect(parsed['error']['message']).to eq('bar')
+    end
+
+    it 'adds the backtrace with rescue_option[:backtrace] specified' do
+      error = Grape::ErrorFormatter::Json.call('',
+                                               'backtrace',
+                                               rescue_options: {backtrace: true})
+      parsed = JSON.parse(error)
+      expect(parsed['backtrace']).to eq('backtrace')
+    end
+  end
+end

data/spec/grape_extensions/include_nil_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'service_template/output_formatters/include_nil'
+require 'service_template/grape_extensions/grape_helpers'
+require 'pry'
+
+describe ServiceTemplate::Representable::IncludeNil do
+  class FooRepresenter < ServiceTemplate::Representer
+    include ServiceTemplate::Representable::IncludeNil
+    property :foo
+    property :bar
+  end
+
+  class DummyClass
+    include ServiceTemplate::GrapeHelpers
+  end
+
+  it 'includes nil keys in a represented hash' do
+    input = OpenStruct.new(foo: 1, bar: nil)
+    output = DummyClass.new.represent(input, with: FooRepresenter).to_h
+    expect(output[:data]).to have_key('foo')
+    expect(output[:data]).to have_key('bar')
+  end
+end

data/spec/identity_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'service_template/identity'
+
+describe ServiceTemplate::Identity do
+  context '#name' do
+    it "returns 'api-service' if no ENV['SERVICE_NAME'] is set" do
+      ENV['SERVICE_NAME'] = nil
+      expect(ServiceTemplate::Identity.name).to eq('api-service')
+    end
+
+    it "returns the ENV['SERVICE_NAME'] when specified" do
+      ENV['SERVICE_NAME'] = nil
+      ENV['SERVICE_NAME'] = 'my-service'
+      expect(ServiceTemplate::Identity.name).to eq('my-service')
+    end
+  end
+
+  context '#hostname' do
+    it 'returns the value of the hostname system call and doesn\'t make a second system call' do
+      expect(ServiceTemplate::Identity).to receive(:`).with('hostname').and_return('system-hostname')
+      expect(ServiceTemplate::Identity.hostname).to eq('system-hostname')
+
+      expect(ServiceTemplate::Identity).to_not receive(:`).with('hostname')
+      expect(ServiceTemplate::Identity.hostname).to eq('system-hostname')
+    end
+  end
+
+  context '#revision' do
+    it 'returns the value of the \'git rev-parse HEAD\' system call and doesn\'t make a second system call' do
+      expect(ServiceTemplate::Identity).to receive(:`).with('git rev-parse HEAD').and_return('12345')
+      expect(ServiceTemplate::Identity.revision).to eq('12345')
+
+      expect(ServiceTemplate::Identity).to_not receive(:`).with('git rev-parse HEAD')
+      expect(ServiceTemplate::Identity.revision).to eq('12345')
+    end
+  end
+
+  context '#pid' do
+    it 'returns the process ID value' do
+      allow(Process).to receive(:pid).and_return(112233)
+      expect(ServiceTemplate::Identity.pid).to eq(112233)
+    end
+  end
+
+  context '#platform_revision' do
+    it 'returns the current version of the platform gem' do
+      expect(ServiceTemplate::Identity.platform_revision).to eq(ServiceTemplate::VERSION)
+    end
+  end
+end

data/spec/json_error_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'service_template/json_error'
+
+describe ServiceTemplate::JsonError do
+  context '#to_json' do
+    it 'returns a json hash with the error data' do
+      error = ServiceTemplate::JsonError.new(:code, 'message').to_json
+      parsed = JSON.parse(error)
+
+      expect(parsed['error']['code']).to eq('code')
+      expect(parsed['error']['message']).to eq('message')
+    end
+
+    it 'returns a json hash with additional reasons' do
+      error = ServiceTemplate::JsonError.new(:code, 'message', {foo: 'bar'}).to_json
+      parsed = JSON.parse(error)
+
+      expect(parsed['error']['code']).to eq('code')
+      expect(parsed['error']['message']).to eq('message')
+      expect(parsed['error']['reasons']['foo']).to eq('bar')
+    end
+
+    it 'excludes `reasons` from hash if no reasons given' do
+      error = ServiceTemplate::JsonError.new(:code, 'message').to_json
+      parsed = JSON.parse(error)
+
+      expect(parsed['error']['code']).to eq('code')
+      expect(parsed['error']['message']).to eq('message')
+      expect(parsed['error']['reasons']).to be nil
+    end
+
+  end
+end

data/spec/logger/log_transaction_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'service_template/logger/log_transaction'
+
+describe ServiceTemplate::LogTransaction do
+  before(:each) do
+    ServiceTemplate::LogTransaction.clear
+  end
+
+  context '#id' do
+    it 'returns the current transaction id if it has been set' do
+      id = SecureRandom.hex(10)
+      Thread.current[:service_template_tid] = id
+      expect(ServiceTemplate::LogTransaction.id).to eq(id)
+    end
+
+    it 'sets and returns a new id if the transaction id hasn\'t been set' do
+      expect(ServiceTemplate::LogTransaction.id).to_not be_nil
+    end
+
+    it 'allows the id to be overridden by a setter' do
+      expect(ServiceTemplate::LogTransaction.id).to_not be_nil
+      ServiceTemplate::LogTransaction.id = 'foo'
+      expect(ServiceTemplate::LogTransaction.id).to eq('foo')
+    end
+  end
+
+  context '#clear' do
+    it 'sets the id to nil' do
+      expect(ServiceTemplate::LogTransaction.id).to_not be_nil
+      ServiceTemplate::LogTransaction.clear
+      expect(Thread.current[:service_template_tid]).to be_nil
+    end
+  end
+end