cadenero 0.0.2.b6 → 0.0.2.b7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YThjNmYyZmE3NmM0MjAxYzUwZDdmOWU4NDgwYWI1NTBiNGFkYWM2Zg==
+    Y2Y5NTFlM2YzZjVjMzY2OTBjMDg2ZDA2NmVhZWY1MmM4OWUzYTc4OA==
   data.tar.gz: !binary |-
-    ZGJlZjBlZGE5YTRmZGYzMmQ4MGM3OGRhYjJjYTEwYjg4ZTk3OTU2Zg==
+    MjE3ZTBmODY0MDJlOGRkYTQ0NjYwYTVlOTAyMzY3YWEwNjRlOGUxMg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NDMyZDdmZDBmNGUxZmZjMWU5YjMyMDI5OTU2YTRkZGMxMGJkOGY3YTMzMTFk
-    YTgxNGY4MzE2YmVmMTIyNTczOTM1OTQ3Nzg2MDRkZWYxYjAxMmY1ZjgzY2Nm
-    ODM0ZGRiN2IwMzJhYjQ0NzJiMjQ2OTMzN2ZiMGRkMmM4NjVkNTI=
+    NGYyN2MyNDk2YWVjYWE0ZWIyZDcyNjEzMWNlNzA1MTMwNzQ5YzQ1MDM5NmZk
+    NjU1ZDljZmYyYzk0YWVhZTU3YmJjMDY2MjVkYTEzMzdlNThiMDEyZWZkM2M2
+    YTRjYWViNzczZmY0MTEyNDdkYmRjYWVhN2Y2YWM1MDJlYTE4OWY=
   data.tar.gz: !binary |-
-    YzdkZTgxMzQ3MzBmMTMxNDMzNGU2ODU3YjNjY2U2NTcxNDg3MjhhZmI5NWU3
-    NzgwYzFhODUxZGI4Y2Y4ZDk0YjU2Njk5ODNkNWY0NWQ0YWQ1M2RmNWMwYzFj
-    NmY1ZmNjMmE3NzA0OWM2YTU0NjllYTdjNDM1ZWZhODgxZGIxZWM=
+    NmZhYmMyMDEwNzAzOTMxYmNlYjM5YzBmMzIyY2FhNDc5MTkzZTM3NzJjYTJh
+    NjAwNjYyMDliMmY1NmZkZTdmY2U4YjNiZGNjNzViMjc5YzEzNDg2MmViZDE5
+    OGJkOTc1ZmZjNzBiMzA4YzgzZjZlMTg1ZmE5MTdhYjQxYTg4ZWE=

data/README.md

@@ -7,6 +7,8 @@ By [![Agiltec Logo](https://launchrock-assets.s3.amazonaws.com/logo-files/Gpujzv
 [![Coverage Status](https://coveralls.io/repos/AgilTec/cadenero/badge.png?branch=master)](https://coveralls.io/r/AgilTec/cadenero?branch=master)
 [![Dependency Status](https://gemnasium.com/AgilTec/cadenero.png)](https://gemnasium.com/AgilTec/cadenero)
 
+THIS README IS FOR THE MASTER BRANCH OF **CADENERO** AND REFLECTS THE WORK CURRENTLY EXISTING ON THE MASTER BRANCH. IF YOU ARE WISHING TO USE A NON-MASTER BRANCH OF **CADENERO**, PLEASE CONSULT THAT BRANCH'S README AND NOT THIS ONE.
+
 Authentication Engine for Rails.API multitenant RESTful APIs based on Warden. It:
 * Is Racked based
 * Use token authentication as strategy for the API
@@ -17,22 +19,43 @@ Authentication Engine for Rails.API multitenant RESTful APIs based on Warden. It
 
 ### Why Cadenero?
 **"Cadenero"** is the spanish word for ["Bouncer (doorman)"](http://en.wikipedia.org/wiki/Bouncer_(doorman\)). The main function of **Cadenero** is to be a resource for authenticating consumers of the services that the API provides. As the real bouncers, **Cadenero** aims to provide security, check authorized access, to refuse entry for intoxication, aggressive behavior or non-compliance with statutory or establishment rules.
+
 You can use [Warden](https://github.com/hassox/warden) or [Devise](https://github.com/plataformatec/devise) directly but for API apps the rewritting and monkey patching can be messy.
 
 ### Installing **Cadenero**
 
+#### Preconditions
+
+##### Postgresql
+You should have a Postgresql server (for downloading see: http://www.postgresql.org/download/). If you are using OSX, you can install using [Homebrew](http://mxcl.github.io/homebrew/) for that you can follow the following this [instructions](http://www.moncefbelyamani.com/how-to-install-postgresql-on-a-mac-with-homebrew-and-lunchy/)
+
+##### Ruby 1.9.x or 2.x
+For that we recommend that you use [rbenv](https://github.com/sstephenson/rbenv) with [ruby-build](https://github.com/sstephenson/ruby-build) or [rvm](https://rvm.io/)
+
+We use the standard `rake`, `bundler` and `gem`
+
+##### Git/Github
+You are here. Then you know what to do ;-)
+
+#### Setup
+
 Rails 3.2.13 is the master version used now by **Cadenero**, if you want to use Rails 4 goodness please use the branch "rails4"
 
 Generate first your Rails app as usual using:
 
 ```
-    $ rails _3.2.13_ new your_app --skip-test-unit
+    $ rails _3.2.13_ new your_app --skip-test-unit  -d postgresql
 ```
 
 In the `Gemfile` add the following lines:
 ```ruby
-    gem 'cadenero', '~> 0.0.2.b6'
-    gem 'pg'
+    gem 'cadenero', '~> 0.0.2.b7'
+
+    group :development, :test do
+      gem 'rspec-rails', '~> 2.14.0'
+      gem 'capybara', '~> 2.1.0'
+      gem 'rack-test', '~> 0.6.2'
+    end
 ```
 
 In the `config/database.yml` replace the `sqlite3` adapter for `postgresql` as follow:
@@ -40,12 +63,16 @@ In the `config/database.yml` replace the `sqlite3` adapter for `postgresql` as f
 ```
     development:
       adapter: postgresql
+      encoding: unicode
       database: your_app_development 
+      pool: 5
       min_messages: warning
 
     test:
       adapter: postgresql
-      database: your_app_test 
+      encoding: unicode
+      database: your_app_test
+      pool: 5
       min_messages: warning
 ```
 
@@ -114,6 +141,15 @@ You can check them running:
 ```
     $ rake routes
 ```
+### Strategies
+For authentication **Cadenero** has two default Warden Strategies:
+  * **Password**. That expect that the client to keep a session cookie and using for authentication the user `email` and `password`.
+  * **Token Authentication**. That is stateless and expects that for each request the user include the `auth_token` as a key-value of the request params.
+
+In any case when you signed up **Cadenero** creates an auth_token for the membership to the account that you signed up.
+
+If you want to know more about Warden Strategies see: https://github.com/hassox/warden/wiki/Strategies
+
 ### Documentation
 You can review the YARD docs in: http://rubydoc.info/github/AgilTec/cadenero/frames
 
@@ -135,14 +171,20 @@ If you found a security bug, do *NOT* use the GitHub issue tracker. Send an emai
 
 ### Contributing
 
-We hope that you will consider contributing to **Cadenero**. Please read this short overview for some information about how to get started:
+We hope that you will consider contributing to **Cadenero**. You're encouraged to submit pull requests, propose features and discuss issues.
 
-https://github.com/AgilTec/cadenero/Contributing
+  * Fork the project
+  * Write test for your new feature or a test that reproduces a bug
+  * Implement your feature or make a bug fix
+  * Commit, push and make a pull request. Bonus points for topic branches.
 
-You will usually want to write tests for your changes using BDD tools as RSpec, Rack::Test and Capybara.  To run the test suite, go into **Cadenero**'s top-level directory and run "bundle install" and "rspec".  For the tests to pass, you will need to have a Postgresql server running on your system.
+You will usually want to write tests for your changes using BDD tools as RSpec, Rack::Test and Capybara.
+
+To run the test suite, go into **Cadenero**'s top-level directory and run `bundle install` and `rspec spec`.  For the tests to pass, you will need to have a Postgresql server running on your system.
 
 #### Running the Specs
-**Cadenero** use [RSpec](https://github.com/rspec/rspec) and [Capybara](https://github.com/jnicklas/capybara). If you want to extend **Cadenero** please fork and clone the repo. To run the specs you only need to do:
+**Cadenero** use [RSpec](https://github.com/rspec/rspec) and [Capybara](https://github.com/jnicklas/capybara). To run the specs you only need to do:
+
 ```
     $ RAILS_ENV=test bundle exec rake db:create
     $ RAILS_ENV=test bundle exec rake db:migrate
@@ -157,7 +199,10 @@ You can `binstub` the command bins to avoid writing `bundle exec`. You only need
 
 ### Warden
 
-**Cadenero** is based on Warden, which is a general Rack authentication framework created by Daniel Neighman. We encourage you to read more about Warden here: https://github.com/hassox/warden
+**Cadenero** is based on [Warden](https://github.com/hassox/warden), which is a general Rack authentication framework created by Daniel Neighman. We encourage you to read more about Warden here: https://github.com/hassox/warden/wiki
+
+#### Devise
+Some code and architectural decisions in **Cadenero** have been inspired for the excellent gem [Devise](https://github.com/plataformatec/devise).
 
 ### Rails::API
 

data/app/extenders/controllers/application_controller_decorator.rb

@@ -30,13 +30,17 @@
 
 # Check to see if there is an authenticated user
   def user_signed_in?
+    unless env['action_dispatch.request.parameters']["auth_token"].nil?
+      env['warden'].logout(:user)
+      env['warden'].authenticate(:token_authentication, scope: :user)
+    end
     env['warden'].authenticated?(:user) unless env['warden'].nil?
   end
 
 # it the user is not authenticated returns a 422 and an informative error with the link for sign
   def authenticate_user!
     unless user_signed_in?
-      @errors = %Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} to /v1/sessions}
+      @errors = %Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} or {"user": {"auth_token": d8Ff8uvupXQfChangeMe}} to /v1/sessions}
       render json: {errors: @errors, links: "/v1/sessions"}, status: 422
     end
   end

data/app/models/cadenero/auth_token.rb

@@ -0,0 +1,35 @@
+# Mixin for Models that have an auth_token
+module Cadenero::AuthToken
+
+  # Generate authentication token unless already exists.
+  def ensure_auth_token
+    reset_auth_token if auth_token.blank?
+  end
+
+  # Generate authentication token unless already exists and save the record.
+  def ensure_auth_token!
+    reset_auth_token! if auth_token.blank?
+  end
+
+  # Generate new authentication token (a.k.a. "single access token").
+  def reset_auth_token
+    self.auth_token = generate_token(:auth_token)
+  end
+
+  # Generate new authentication token and save the record.
+  def reset_auth_token!
+    reset_auth_token
+    save(:validate => false)
+  end
+
+  protected
+  # Generate a token by looping and ensuring does not already exist.
+  # @param [String] column is the name of the column that has the authentication token
+  # @return {String]} a unique generated auth_token
+  def generate_token(column)
+    loop do
+      token = SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
+      break token unless self.class.where({ column => token }).first
+    end
+  end
+end

data/app/models/cadenero/member.rb

@@ -1,50 +1,12 @@
 module Cadenero
   # Defines that a Cadenero::User is member of an Cadenero::V1::Account
   class Member < ActiveRecord::Base
+    include Cadenero::AuthToken
     attr_accessible :account_id, :user_id
     belongs_to :account,  :class_name => "Cadenero::V1::Account"
     belongs_to :user,  :class_name => "Cadenero::User"
     after_create :ensure_auth_token!
 
-    # Generate authentication token unless already exists.
-    def ensure_auth_token
-      reset_auth_token if auth_token.blank?
-    end
-
-    # Generate authentication token unless already exists and save the record.
-    def ensure_auth_token!
-      reset_auth_token! if auth_token.blank?
-    end
-
-    # Generate new authentication token (a.k.a. "single access token").
-    def reset_auth_token
-      self.auth_token = self.class.auth_token
-    end
-
-    # Generate new authentication token and save the record.
-    def reset_auth_token!
-      reset_auth_token
-      save(:validate => false)
-    end
-
-    class << self
-      # Generate a token checking if one does not already exist in the database.
-      def auth_token
-        generate_token(:auth_token)
-      end
-
-      protected
-      # Generate a token by looping and ensuring does not already exist.
-      # @param [String] column is the name of the column that has the authentication token
-      # @return {String]} a unique generated auth_token
-      def generate_token(column)
-        loop do
-          token = SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
-          break token unless Member.where({ column => token }).first
-        end
-      end
-    end
-
   end
   
 end

data/app/models/cadenero/user.rb

@@ -7,10 +7,9 @@ module Cadenero
     has_many :members, class_name: "Cadenero::Member"
     has_many :memberships, through: :members, source: :account
 
-    # Obtain the authentication_token from the members to be use for the User
+    # Map the auth_tokens for each account that the User is memeber
     def auth_token
       members.map{|member| member.auth_token}
     end
-
   end
 end

data/app/models/cadenero/v1/account.rb

@@ -1,6 +1,7 @@
 module Cadenero::V1
   # Defines a subdomain with a default admin (owner) as a tenant in the Rails App
   class Account < ActiveRecord::Base
+    include Cadenero::AuthToken
     belongs_to :owner,  :class_name => "Cadenero::User"
     has_many :members, :class_name => "Cadenero::Member"
     has_many :users, :through => :members,  :class_name => "Cadenero::User"
@@ -9,7 +10,7 @@ module Cadenero::V1
     attr_accessible :name, :subdomain, :owner_attributes, :owner
     validates :subdomain, :presence => true, :uniqueness => true
     validates :owner, :presence => true
-    after_create :ensure_authentication_token!
+    after_create :ensure_auth_token!
 
     # Creates an account and assign the provided [Cadenero::User] as owner to the account
     # @param [Hash] params list
@@ -24,7 +25,7 @@ module Cadenero::V1
       if account.save
         account.users << account.owner
         account.create_schema
-        account.ensure_authentication_token!
+        account.ensure_auth_token!
       end
       account
     end
@@ -48,49 +49,5 @@ module Cadenero::V1
       Apartment::Database.create(subdomain)
     end
 
-    # Obtain the auth_token from the members to be use for the Account
-    def auth_token
-      members.map{|member| member.auth_token}
-    end
-
-    # Generate authentication token unless already exists.
-    def ensure_authentication_token
-      reset_authentication_token if authentication_token.blank?
-    end
-
-    # Generate authentication token unless already exists and save the record.
-    def ensure_authentication_token!
-      reset_authentication_token! if authentication_token.blank?
-    end
-
-    # Generate new authentication token (a.k.a. "single access token").
-    def reset_authentication_token
-      self.authentication_token = self.class.authentication_token
-    end
-
-    # Generate new authentication token and save the record.
-    def reset_authentication_token!
-      reset_authentication_token
-      save(:validate => false)
-    end
-
-    class << self
-      # Generate a token checking if one does not already exist in the database.
-      def authentication_token
-        generate_token(:authentication_token)
-      end
-
-      protected
-      # Generate a token by looping and ensuring does not already exist.
-      # @param [String] column is the name of the column that has the authentication token
-      # @return {String]} a unique generated authentication_token
-      def generate_token(column)
-        loop do
-          token = SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
-          break token unless Account.where({ column => token }).first
-        end
-      end
-    end
-
   end
 end

data/config/initializers/apartment.rb

@@ -9,4 +9,6 @@ Apartment.configure do |config|
                              "Cadenero::User"]
   # Dynamically get database names to migrate
   # config.database_names = lambda{ Account.pluck(:database_name) }
-end
+end
+
+Apartment.database_names = lambda{ Cadenero::V1::Account.pluck(:subdomain)}

data/config/initializers/warden/strategies/token_authentication.rb

@@ -0,0 +1,35 @@
+Warden::Strategies.add(:token_authentication) do
+  def subdomain
+    ActionDispatch::Http::URL.extract_subdomains(request.host, 1)
+  end
+
+  def json_params
+    unless params.empty?
+      params
+    else
+      @json ||= env['rack.input'].gets
+      JSON.parse(@json)
+    end
+  end
+
+  def valid?
+    subdomain.present? && json_params["auth_token"]
+  end
+
+  def authenticate!
+    account = Cadenero::V1::Account.get_by_subdomain(subdomain)
+    if account
+      member = account.members.where(auth_token: json_params["auth_token"]).first
+      u = nil
+      u = member.user unless member.nil?
+      if u.nil? || u.blank?
+        fail!
+      else
+        env['warden'].set_user(u.id, :scope => :user)
+        success!(u)
+      end
+    else
+      fail!
+    end
+  end
+end

data/config/initializers/warden.rb

@@ -1,4 +1,4 @@
 Rails.application.config.middleware.use Warden::Manager do |manager|
   manager.failure_app = Cadenero::V1::Account::DashboardController.action(:index)
-  manager.default_strategies :password
+  manager.default_strategies :password, :token_authentication
 end

data/db/migrate/20130612061604_create_cadenero_v1_accounts.rb

@@ -3,12 +3,12 @@ class CreateCadeneroV1Accounts < ActiveRecord::Migration
     create_table :cadenero_accounts do |t|
       t.string :name
       t.string :subdomain
-      t.string :authentication_token
+      t.string :auth_token
       t.references :owner
 
       t.timestamps
     end
     add_index :cadenero_accounts, :owner_id
-    add_index :cadenero_accounts, :authentication_token
+    add_index :cadenero_accounts, :auth_token
   end
 end

data/lib/cadenero/testing_support/authentication_helpers.rb

@@ -46,7 +46,7 @@ module Cadenero
       # Expect that the JSON response will be a default error message when the user has not signed in yet
       # the errors_redirect_ro_sign_in is defined if was not previously defined is a Spec
       def check_error_for_not_signed_in_yet
-        errors_redirect_ro_sign_in ||= {errors: %Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} to /v1/sessions}, links: "/v1/sessions"}.to_json
+        errors_redirect_ro_sign_in ||= {errors: %Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} or {"user": {"auth_token": d8Ff8uvupXQfChangeMe}} to /v1/sessions}, links: "/v1/sessions"}.to_json
         get cadenero.v1_root_url(:subdomain => account.subdomain)
         expected_json_errors(errors_redirect_ro_sign_in)
       end
@@ -73,23 +73,23 @@ module Cadenero
       # @param [Integer] http_code Optional expected returned HTTP Code from last_response
       def expect_subject_ids_to_have(subject, ids_key, ids_values, http_code=201)
         expect(last_response.status).to eq http_code
-        expect(json_last_response_body[subject][ids_key]).to eq ids_values
+        expect(json_last_response_body[subject][ids_key].sort).to eq ids_values.sort
       end
 
-      # Expect that a owner sign in successfuly to one of his accounts
+      # Expect that a owner sign in successfuly to one of his accounts creating a session
       # @param  [Cadenero::V1::Account] account
       # @return [String] email  for the last response user
-      def successful_sign_in_owner(account)
+      def successful_sign_in_owner_with_session(account)
         sign_in_user sessions_url, account_user_params_json(account.owner)
         expect_subject_ids_to_have("user", "account_ids", [account.id])
-        expect_auth_token("user", account.auth_token)
+        expect_auth_token("user", account.owner.auth_token)
         return json_last_response_body["user"]["email"]
       end
 
       # Expect that a user sign in successfuly to an account
       # @param  [Cadenero::V1::Account] account
       # @return [String] email  for the last response user
-      def successful_sign_in_user(account, user)
+      def successful_sign_in_user_with_session(account, user)
         sign_in_user sessions_url, user
         expect_subject_ids_to_have("user", "membership_ids", [account.id])
         return json_last_response_body["user"]["email"]
@@ -98,7 +98,7 @@ module Cadenero
       # Expect that a user sign in successfuly to an account
       # @param  [Cadenero::V1::Account] account
       # @return [String] email  for the last response user
-      def successful_sign_up_user_in_existing_account(account, suffix=nil)
+      def successful_sign_up_user_in_existing_account_with_session(account, suffix=nil)
         url = "http://#{account.subdomain}.example.com/" 
         sign_up_user url, suffix
         expect(last_request.url).to eq "#{url}v1/users"

data/lib/cadenero/version.rb

@@ -1,3 +1,3 @@
 module Cadenero
-  VERSION = "0.0.2.b6" # Current VERSION of Cadenero
+  VERSION = "0.0.2.b7" # Current VERSION of Cadenero
 end

data/spec/controllers/cadenero/v1/accounts_controller_spec.rb

@@ -17,7 +17,7 @@ module Cadenero
         post :create, format: :json, account: { name: "First Account", subdomain: "first" }, use_route: :cadenero
         expect(response.status).to eq(201)
         expect(assigns(:account)).to eq(account)
-        expect(assigns(:account)[:authentication_token]).to eq(account.authentication_token)
+        expect(assigns(:account)[:authentication_token]).to eq(account.auth_token)
       end
     end
 

data/spec/controllers/cadenero/v1/users_controller_spec.rb

@@ -5,7 +5,7 @@ module Cadenero
     let!(:user) { stub_model(Cadenero::User, id: 101, email: "testy@example.com", password: "12345678")}
     let!(:account) { stub_model(Cadenero::V1::Account, id: 1001, authentication_token: "dsdaefer412add", 
       owner: user) }
-    let(:errors_redirect_ro_sign_in) {%Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} to /v1/sessions}}
+    let(:errors_redirect_ro_sign_in) {%Q{Please sign in. posting the user json credentials as: {"user": {"email": "testy2@example.com", "password": "changeme"}} or {"user": {"auth_token": d8Ff8uvupXQfChangeMe}} to /v1/sessions}}
   
 
     context "User signed out" do  

data/spec/dummy/db/schema.rb

@@ -16,20 +16,20 @@ ActiveRecord::Schema.define(:version => 20130715174857) do
   create_table "cadenero_accounts", :force => true do |t|
     t.string   "name"
     t.string   "subdomain"
-    t.string   "authentication_token"
+    t.string   "auth_token"
     t.integer  "owner_id"
-    t.datetime "created_at",           :null => false
-    t.datetime "updated_at",           :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
   end
 
-  add_index "cadenero_accounts", ["authentication_token"], :name => "index_cadenero_accounts_on_authentication_token"
+  add_index "cadenero_accounts", ["auth_token"], :name => "index_cadenero_accounts_on_auth_token"
   add_index "cadenero_accounts", ["owner_id"], :name => "index_cadenero_accounts_on_owner_id"
 
   create_table "cadenero_members", :force => true do |t|
     t.integer  "account_id"
     t.integer  "user_id"
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
     t.string   "auth_token"
   end
 
@@ -40,8 +40,8 @@ ActiveRecord::Schema.define(:version => 20130715174857) do
   create_table "cadenero_users", :force => true do |t|
     t.string   "email"
     t.string   "password_digest"
-    t.datetime "created_at",      :null => false
-    t.datetime "updated_at",      :null => false
+    t.datetime "created_at"
+    t.datetime "updated_at"
   end
 
 end

data/spec/dummy/db/seeds.rb

@@ -5,4 +5,4 @@
                                                             password_confirmation: '12345678'))
 
 @account.create_schema
-@account.ensure_authentication_token!
+@account.ensure_auth_token!

data/spec/dummy/log/development.log

@@ -370,3 +370,40 @@ Processing by Cadenero::V1::Account::DashboardController#index as HTML
   Parameters: {"default"=>:json}
 Filter chain halted as :authenticate_user! rendered or redirected
 Completed 422 Unprocessable Entity in 5ms (Views: 0.3ms | ActiveRecord: 0.0ms)
+Connecting to database specified by database.yml
+   (7.2ms)  CREATE TABLE "schema_migrations" ("version" character varying(255) NOT NULL) 
+   (1.9ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+Migrating to CreateCadeneroV1Accounts (20130612061604)
+   (0.1ms)  BEGIN
+   (6.7ms)  CREATE TABLE "cadenero_accounts" ("id" serial primary key, "name" character varying(255), "subdomain" character varying(255), "authentication_token" character varying(255), "owner_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (0.9ms)  CREATE INDEX "index_cadenero_accounts_on_owner_id" ON "cadenero_accounts" ("owner_id")
+   (0.8ms)  CREATE INDEX "index_cadenero_accounts_on_authentication_token" ON "cadenero_accounts" ("authentication_token")
+   (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20130612061604')
+   (1.1ms)  COMMIT
+Migrating to CreateCadeneroV1Users (20130612064652)
+   (0.2ms)  BEGIN
+   (4.5ms)  CREATE TABLE "cadenero_users" ("id" serial primary key, "email" character varying(255), "password_digest" character varying(255), "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (0.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20130612064652')
+   (0.9ms)  COMMIT
+Migrating to CreateCadeneroV1Members (20130612073709)
+   (0.2ms)  BEGIN
+   (4.5ms)  CREATE TABLE "cadenero_members" ("id" serial primary key, "account_id" integer, "user_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (1.4ms)  CREATE INDEX "index_cadenero_members_on_account_id" ON "cadenero_members" ("account_id")
+   (6.1ms)  CREATE INDEX "index_cadenero_members_on_user_id" ON "cadenero_members" ("user_id")
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20130612073709')
+   (0.8ms)  COMMIT
+Migrating to AddAuthTokenToCadeneroMembers (20130715174857)
+   (0.2ms)  BEGIN
+   (9.1ms)  ALTER TABLE "cadenero_members" ADD COLUMN "auth_token" character varying(255)
+   (1.3ms)  CREATE INDEX "index_cadenero_members_on_auth_token" ON "cadenero_members" ("auth_token")
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20130715174857')
+   (0.5ms)  COMMIT
+Migrating to RenameAuthenticationTokenToV1Account (20130717234244)
+   (0.1ms)  BEGIN
+   (0.2ms)  ALTER TABLE "cadenero_accounts" RENAME COLUMN "authentication_token" TO "auth_token"
+   (1.1ms)  CREATE INDEX "index_cadenero_accounts_on_auth_token" ON "cadenero_accounts" ("auth_token")
+   (0.6ms)  DROP INDEX "index_cadenero_accounts_on_authentication_token"
+   (0.1ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20130717234244')
+   (1.6ms)  COMMIT
+   (0.2ms)  SELECT "schema_migrations"."version" FROM "schema_migrations"