blamescope 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f0301896ebca21df7ef26fb732142ffe3ad8f3d
+  data.tar.gz: ebbe482c0b14d987baa3e9341eaffdc484c417e8
+SHA512:
+  metadata.gz: 387c2232c674bec8635d2cdacedd89f9353b52373f9aeb931c827d6f40962a33d20d949024d31a824c4741f1acd4cd3a9301ad9491eef9b102b4c7f3218ac679
+  data.tar.gz: 623534cec783f7fd61e99786005566e6cf0beadc52b6d1081a0677ff062a43dea2fe2c5abc0c2fb00c66ce2560b682c4f1447fce7736d31899ccf825142d1260

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+addons:
+  code_climate:
+    repo_token: 857b1adec905710209e302b26df48ef67900dabba836fcddc993334fb035a0ca
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in blamescope.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 vladnik
+
+MIT License
+
+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,70 @@
+# BlameScope
+
+Track events per user
+
+[![Build Status](https://travis-ci.org/Demandbase/blamescope.svg?branch=master)](https://travis-ci.org/Demandbase/blamescope)
+[![Code Climate](https://codeclimate.com/github/Demandbase/blamescope/badges/gpa.svg)](https://codeclimate.com/github/Demandbase/blamescope)
+[![Test Coverage](https://codeclimate.com/github/Demandbase/blamescope/badges/coverage.svg)](https://codeclimate.com/github/Demandbase/blamescope)
+
+### Client mode
+
+Rails setup
+
+    # config/application.rb
+    config.middleware.use Blamescope::Middleware, rabbit: 'amqp://user:pass@host:port/vhost'
+
+Rack setup
+
+    # config.ru
+    use Blamescope::Middleware, rabbit: 'amqp://user:pass@host:port/vhost'
+
+#### Usage
+    
+    class User < ActiveRecord::Base
+      include Blamescope
+
+      blame_activerecord # Tracks create, update and delete action
+      def custom_action
+        # Some action
+      end
+      blame_method :custom_action
+    end
+
+At the current time it adds such methods:
+* blame_activerecord - track create, update, delete of ActiveRecord model
+* blame_method - track specific method
+* blame_methods - track multiple methods
+
+You can also track static methods and Devise is the only authorization it supports.
+
+### Server mode
+    
+    blamescope -d postgres://user:password@host/database -r amqp://user:pass@host:port/vhost
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'blamescope'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install blamescope
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/blamescope/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/bin/blamescope

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'blamescope'
+
+Blamescope::Server.start

data/blamescope.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'blamescope/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "blamescope"
+  spec.version       = Blamescope::VERSION
+  spec.authors       = ["Volodymyr Ladnik"]
+  spec.email         = ["vladnik@demandbase.com"]
+  spec.summary       = %q{Track events per user}
+  spec.description   = %q{Find whom to blame for broken stuff}
+  spec.homepage      = "https://github.com/Demandbase/blamescope"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "bunny"
+  spec.add_dependency "pg"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "pry"
+end

data/lib/blamescope.rb

@@ -0,0 +1,70 @@
+require "bunny"
+require "blamescope/version"
+require "blamescope/middleware"
+require "blamescope/trackable"
+require "blamescope/server"
+
+# 
+# Blamescope module
+# 
+# @author Volodymyr Ladnik
+# 
+module Blamescope
+  class << self
+    attr_accessor :exchange
+
+    def included(base)
+      base.extend(Trackable)
+      base.class.extend(Trackable)
+    end
+
+    # 
+    # Configure Blamescope
+    # @param [Hash] config
+    # @option config [String] :rabbit Rabbit connection in format amqp://user:pass@host:port/vhost
+    # 
+    def configure(config)
+      self.exchange = rabbit_connection(config[:rabbit])[:exchange]
+    end
+
+    # 
+    # Get current user
+    # 
+    # @return [String] user email
+    def user
+      env = Thread.current[:env]
+      if env && env['warden']
+        env['warden'].user.email
+      else
+         "#{ENV['USER']}@#{Socket.gethostname}"
+      end
+    end
+
+    # 
+    # Send event
+    # @param [type] attrs  event attributes
+    # @option attrs [String] :model current class name
+    # @option attrs [String] :action current method
+    # @option attrs [String] :attrs object attributes
+    # 
+    def emit(attrs)
+      attrs[:email] ||= user
+      exchange.publish(attrs.to_json)
+    rescue Bunny::ConnectionClosedError
+      puts "Bunny is down: couldn't send #{attrs[:action]} action for #{attrs[:model]} model"
+    end
+
+    # 
+    # Create RabbitMQ connection
+    # @param config [String] Rabbit connection in format amqp://user:pass@host:port/vhost
+    # 
+    # @return [Hash] rabbit connection, channel and exchange
+    def rabbit_connection(config)
+      conn = Bunny.new(config)
+      conn.start
+      channel = conn.create_channel
+      exchange = channel.fanout("blamescope")
+      {conn: conn, channel: channel, exchange: exchange}
+    end
+  end
+end

data/lib/blamescope/middleware.rb

@@ -0,0 +1,19 @@
+module Blamescope
+  # 
+  # Rack middleware to intercept request environment
+  # 
+  # @author Volodymyr Ladnik
+  # 
+  class Middleware
+    
+    def initialize(app, config = nil)
+      @app = app
+      Blamescope.configure(config) if config
+    end
+
+    def call(env)
+      Thread.current[:env] = env
+      @app.call(env)
+    end
+  end
+end

data/lib/blamescope/server.rb

@@ -0,0 +1,80 @@
+require "pg"
+require "json"
+require "uri"
+require "optparse"
+
+module Blamescope
+  class Server
+    TABLE_QUERY = <<-EOS
+      CREATE TABLE IF NOT EXISTS blamescope (
+        id serial NOT NULL,
+        email character varying(255),
+        action character varying(255),
+        model character varying(255),
+        attributes json,
+        created_at timestamp without time zone,
+        CONSTRAINT blamescope_pkey PRIMARY KEY (id)
+      );
+    EOS
+
+    def self.start(options = {})
+      # Parse options
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: blamescope [options]"
+        opts.on("-d", "--database CONF", "Database connection in format postgres://user:password@host/database") do |d|
+          options[:database] = d
+        end
+        opts.on("-r", "--rabbit CONF", "RabbitMQ connection in format amqp://user:pass@host:port/vhost") do |r|
+          options[:rabbit] = r
+        end
+        opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+          options[:verbose] = v
+        end
+      end
+
+      optparse.parse!
+      if options[:database] && options[:rabbit]
+        new.listen(options)
+      else
+        puts optparse
+      end
+    end
+
+    def listen(config)
+      rabbit = rabbit_connection(config[:rabbit])
+      db = postgres_connection(config[:database])
+      rabbit[:queue].subscribe(block: true) do |delivery_info, properties, body|
+        store_event(db, body)
+      end
+    rescue Interrupt => _
+      rabbit[:channel].close
+      rabbit[:conn].close
+    end
+
+    def store_event(db, body, time = Time.now.utc)
+      event = JSON.parse(body)
+      db.exec_prepared('insert_event', [event['email'], event['action'], event['model'], event['attrs'].to_json, time])
+    end
+
+    def rabbit_connection(config)
+      rabbit = Blamescope.rabbit_connection(config)
+      queue = rabbit[:channel].queue("", exclusive: true)
+      queue.bind(rabbit[:exchange])
+      rabbit[:queue] = queue
+      return rabbit
+    end
+
+    def postgres_connection(config)
+      config = URI.parse(config)
+      params = {host: config.host, dbname: config.path[1..-1]}
+      params[:user] = config.user if config.user
+      params[:password] = config.password if config.password
+      params[:port] = config.port if config.port
+      conn = PG.connect(params)
+      conn.exec(TABLE_QUERY)
+      conn.prepare("insert_event", "INSERT INTO blamescope (email, action, model, attributes, created_at)
+                                    VALUES ($1, $2, $3, $4, $5)")
+      return conn
+    end
+  end
+end

data/lib/blamescope/trackable.rb

@@ -0,0 +1,64 @@
+# 
+# Trackable module
+# 
+# @author Volodymyr Ladnik
+# 
+module Blamescope
+  module Trackable
+
+    # 
+    # Send event for model
+    # @param model [Object] current object
+    # @param method_name [String|Symbol] method invoked
+    # 
+    # @return [type] [description]
+    def self.send_event(model, method_name)
+      class_name = model.class == Class ? model.name : model.class.name
+        attrs = {}
+        attrs[:id] = model.id if model.respond_to? :id
+        if model.respond_to? :name
+          attrs[:name] = model.name
+        elsif model.respond_to? :title
+          attrs[:title] = model.title
+        end
+        Blamescope.emit(model: class_name, action: method_name, attrs: attrs)
+    end
+
+    # 
+    # Track method
+    # @param name [String|Symbol] method name
+    # 
+    def blame_method method_name
+      alias_method "original_#{method_name}", method_name
+      define_method method_name do |*args, &block|
+        Blamescope::Trackable.send_event(self, method_name)
+        send("original_#{method_name}", *args, &block)
+      end
+    end
+
+    # 
+    # Track multiple methods
+    # @param *names [String|Symbol] method name
+    # 
+    def blame_methods *names
+      names.each do |name|
+        blame_method(name)
+      end
+    end
+
+    # 
+    # Track ActiveRecord model
+    # 
+    def blame_activerecord
+      after_create do
+        Blamescope::Trackable.send_event(self, :create)
+      end
+      after_update do
+        Blamescope::Trackable.send_event(self, :update)
+      end
+      after_destroy do
+        Blamescope::Trackable.send_event(self, :delete)
+      end
+    end
+  end
+end

data/lib/blamescope/version.rb

@@ -0,0 +1,3 @@
+module Blamescope
+  VERSION = "0.0.3"
+end

data/spec/blamescope/middleware_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Blamescope
+  describe Middleware do
+    describe "::new" do
+      it "should configure application" do
+        expect(Blamescope).to receive(:configure).with(:config)
+        Middleware.new(:app, :config)
+      end
+    end
+
+    describe "#call" do
+      it "should set environment from request" do
+        app = double('app')
+        expect(Thread).to receive_message_chain(:current, :[]=).with(:env, :env)
+        expect(app).to receive(:call).with(:env)
+        subject = Middleware.new(app)
+        subject.call(:env)
+      end
+    end
+  end
+end

data/spec/blamescope/server_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Blamescope
+  describe Server do
+    describe "::start" do
+      it "should initialize server if options provided" do
+        options = {database: 'db_url', rabbit: 'rabbit_url'}
+        expect(Server).to receive_message_chain(:new, :listen).with(options)
+        Server.start(options)
+      end
+      it "shouldn't initialize server if any option missing" do
+        expect(Server).to receive(:puts).twice
+        expect(Server).not_to receive(:new)
+        Server.start(database: 'db_url')
+        Server.start(rabbit: 'rabbit_url')
+      end
+    end
+
+    describe "#listen" do
+      it "should listen for events" do
+        subject = Server.new
+        queue = double('rabbit queue')
+        expect(queue).to receive(:subscribe).and_yield(:info, :properties,:body)
+        expect(subject).to receive(:rabbit_connection).with(:rabbit).and_return(queue: queue)
+        expect(subject).to receive(:postgres_connection).with(:database).and_return(:db)
+        expect(subject).to receive(:store_event).with(:db, :body)
+        subject.listen(rabbit: :rabbit, database: :database)
+      end
+
+      it "should close channel and connection on interrupt" do
+        subject = Server.new
+        queue = double('rabbit queue')
+        expect(queue).to receive(:subscribe).and_raise(Interrupt)
+        channel = double('rabbit channel')
+        expect(channel).to receive(:close)
+        conn = double('rabbit connection')
+        expect(conn).to receive(:close)
+        expect(subject).to receive(:rabbit_connection).with(:rabbit).and_return(queue: queue, channel: channel, conn: conn)
+        expect(subject).to receive(:postgres_connection).with(:database).and_return(:db)
+        subject.listen(rabbit: :rabbit, database: :database)
+      end
+    end
+    describe "#store_event" do
+      it "should store event" do
+        time = Time.now.utc
+        db = double('database connection')
+        expect(db).to receive(:exec_prepared).with('insert_event',
+                             ['user@example.com', 'create', 'User', '{"id":1}', time])
+        subject = Server.new
+        subject.store_event(db, {email: 'user@example.com', action: 'create', model: 'User', attrs: {id: 1}}.to_json, time)
+      end
+    end
+  end
+end

data/spec/blamescope/trackable_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+class TestClass
+  include Blamescope
+  
+  class << self
+    def static_method arg
+      'static response'
+    end
+    blame_method :static_method
+  end
+
+  def create arg1, arg2
+    'create result'
+  end
+  blame_method :create
+
+  def update arg1, &block
+    return 'block given' if block_given?
+  end
+  blame_method :update
+
+  def name
+    'some name'
+  end
+end
+  
+module Blamescope
+  describe Trackable do    
+    describe "#blame_method" do
+      it "should work with multiple arguments" do
+        instance = TestClass.new
+        expect(Blamescope::Trackable).to receive(:send_event).with(instance, :create)
+        expect(instance).to receive(:original_create).with(:arg1,:arg2).and_call_original
+        expect(instance.create(:arg1,:arg2)).to eq('create result')
+      end
+
+      it "should work with block of code" do
+        instance = TestClass.new
+        expect(Blamescope::Trackable).to receive(:send_event).with(instance, :update)
+        expect(instance).to receive(:original_update).with(:arg1).and_call_original
+        expect(instance.update(:arg1){ block }).to eq('block given')
+      end
+    end
+
+    describe "::blame_method" do
+      it "should work with static methods" do
+        expect(Blamescope::Trackable).to receive(:send_event).with(TestClass, :static_method)
+        expect(TestClass).to receive(:original_static_method).with(:arg1).and_call_original
+        expect(TestClass.static_method(:arg1)).to eq('static response')
+      end
+    end
+
+    describe "#blame_methods" do
+      it "should invoke #track_method for each argument" do
+        expect(TestClass).to receive(:blame_method).with(:first)
+        expect(TestClass).to receive(:blame_method).with(:second)
+        TestClass.blame_methods :first, :second
+      end
+    end
+  end
+end

data/spec/blamescope_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Blamescope do
+  describe "#configure" do
+    it "should create connection" do
+      expect(Blamescope).to receive(:rabbit_connection).with(:config).and_return(exchange: :exchange)
+      Blamescope.configure(rabbit: :config)
+      expect(Blamescope.exchange).to eq(:exchange)
+    end
+  end
+
+  describe "#user" do
+    it "should get user from warden key" do
+      warden = double('warden')
+      allow(warden).to receive_message_chain(:user, email: 'user@example.com')
+      Thread.current[:env] = {'warden' => warden }
+      expect(Blamescope.user).to eq('user@example.com')
+    end
+
+    it "should use system user if warden is not available" do
+      Thread.current[:env] = nil
+      expect(Blamescope.user).to eq("#{ENV['USER']}@#{Socket.gethostname}")
+    end
+  end
+
+  describe "#emit" do
+    it "should publish event" do
+      allow(Blamescope).to receive(:user).and_return('user@example.com')
+      expect(Blamescope).to receive_message_chain(:exchange, :publish).with({model:'USER', email: 'user@example.com'}.to_json)
+      Blamescope.emit(model: 'USER')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'blamescope'
+
+# Configure RSpec
+RSpec.configure do |config|
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: blamescope
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Volodymyr Ladnik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  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: pg
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.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: codeclimate-test-reporter
+  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'
+description: Find whom to blame for broken stuff
+email:
+- vladnik@demandbase.com
+executables:
+- blamescope
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/blamescope
+- blamescope.gemspec
+- lib/blamescope.rb
+- lib/blamescope/middleware.rb
+- lib/blamescope/server.rb
+- lib/blamescope/trackable.rb
+- lib/blamescope/version.rb
+- spec/blamescope/middleware_spec.rb
+- spec/blamescope/server_spec.rb
+- spec/blamescope/trackable_spec.rb
+- spec/blamescope_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Demandbase/blamescope
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Track events per user
+test_files:
+- spec/blamescope/middleware_spec.rb
+- spec/blamescope/server_spec.rb
+- spec/blamescope/trackable_spec.rb
+- spec/blamescope_spec.rb
+- spec/spec_helper.rb