describe 'the authenticate method for User' do
describe 'if the user is an admin' do

describe '.authenticate' do
describe '#admin?' do

it 'has 200 status code if logged in' do
  expect(response).to respond_with 200
end
it 'has 401 status code if not logged in' do
  expect(response).to respond_with 401
end

context 'when logged in' do
  it { is_expected.to respond_with 200 }
end
context 'when logged out' do
  it { is_expected.to respond_with 401 }
end

it 'has 422 status code if an unexpected params will be added' do

context 'when not valid' do
  it { should respond_with 422 }
end

when not valid
  it should respond with 422

it { should respond_with_content_type(:json) }
it { should assign_to(:resource) }

it 'creates a resource' do
  expect(response).to respond_with_content_type(:json)
  expect(response).to assign_to(:resource)
end

before_filter :find_owned_resources
before_filter :find_resource

def destroy
  render 'show'
  @consumption.destroy
end

it 'shows the resource'

it 'creates a resource' do
  response.should respond_with_content_type(:json)
end

it 'creates a resource' do
  expect(response).to respond_with_content_type(:json)
end

# spec_helper.rb
RSpec.configure do |config|
  # ...
  config.expect_with :rspec do |c|
    c.syntax = :expect
  end
end

it { expect(assigns('message')).to match /it was born in Belville/ }

subject { assigns('message') }
it { should match /it was born in Billville/ }

subject(:hero) { Hero.first }
it "carries a sword" do
  expect(hero.equipment).to include "sword"
end

describe '#type_id' do
  before { @resource = FactoryGirl.create :device }
  before { @type     = Type.find @resource.type_id }

  it 'sets the type_id field' do
    expect(@resource.type_id).to equal(@type.id)
  end
end

describe '#type_id' do
  let(:resource) { FactoryGirl.create :device }
  let(:type)     { Type.find resource.type_id }

  it 'sets the type_id field' do
    expect(resource.type_id).to equal(type.id)
  end
end

context 'when updates a not existing property value' do
  let(:properties) { { id: Settings.resource_id, value: 'on'} }

  def update
    resource.properties = properties
  end

  it 'raises a not found error' do
    expect { update }.to raise_error Mongoid::Errors::DocumentNotFound
  end
end

# this:
let(:foo) { Foo.new }

# is very nearly equivalent to this:
def foo
  @foo ||= Foo.new
end

# simulate a not found resource
context "when not found" do
  before do
    allow(Resource).to receive(:where).with(created_from: params[:id])
      .and_return(false)
  end
  it { should respond_with 404 }
end

describe "User"
  describe ".top" do
    before { FactoryGirl.create_list(:user, 3) }
    it { expect(User.top(2)).to have(2).item }
  end
end

user = User.create(
  name: 'Genoveffa',
  surname: 'Piccolina',
  city: 'Billyville',
  birth: '17 Agoust 1982',
  active: true
)

user = FactoryGirl.create :user

lambda { model.save! }.to raise_error Mongoid::Errors::DocumentNotFound

expect { model.save! }.to raise_error Mongoid::Errors::DocumentNotFound

describe 'GET /devices' do
  let!(:resource) { FactoryGirl.create :device, created_from: user.id }
  let(:uri) { '/devices' }

  context 'when shows all resources' do
    let!(:not_owned) { FactoryGirl.create factory }

    it 'shows all owned resources' do
      page.driver.get uri
      expect(page.status_code).to be(200)
      contains_owned_resource resource
      does_not_contain_resource not_owned
    end
  end

  describe '?start=:uri' do
    it 'shows the next page' do
      page.driver.get uri, start: resource.uri
      expect(page.status_code).to be(200)
      contains_resource resources.first
      expect(page).to_not have_content resource.id.to_s
    end
  end
end

describe 'GET /devices' do

  let!(:resource) { FactoryGirl.create :device, created_from: user.id }
  let(:uri)       { '/devices' }

  it_behaves_like 'a listable resource'
  it_behaves_like 'a paginable resource'
  it_behaves_like 'a searchable resource'
  it_behaves_like 'a filterable list'
end

it 'should not change timings' do
  consumption.occur_at.should == valid.occur_at
end

it 'does not change timings' do
  expect(consumption.occur_at).to equal(valid.occur_at)
end

bundle exec guard

guard 'rspec', cli: '--drb --format Fuubar --color', version: 2 do
  # すべての更新されたspecを実行
  watch(%r{^spec/.+_spec\.rb$})
  # lib/フォルダーの中のファイルが変更された時libのspecを実行
  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
  # モデルが変更された時関連モデルのspecを実行
  watch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
  # ビューが変更された時関連ビューのspecを実行
  watch(%r{^app/(.*)(\.erb|\.haml)$}) { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
  # コントローラが変更された時コントローラと関連ある統合テストのspecを実行
  watch(%r{^app/controllers/(.+)\.rb}) { |m| "spec/requests/#{m[1]}_spec.rb" }
  # application_controllerが変更された時すべての統合テストのspecを実行
  watch('app/controllers/application_controller.rb') { "spec/requests" }
end

context "with unauthorized access" do
  let(:uri) { 'http://api.lelylan.com/types' }
  before    { stub_request(:get, uri).to_return(status: 401, body: fixture('401.json')) }
  it "gets a not authorized notification" do
    page.driver.get uri
    expect(page).to have_content 'Access denied'
  end
end

# Gemfile
group :development, :test do
  gem 'fuubar'

# Guardfile
guard 'rspec' do
  # ...
end

# .rspec
--drb
--format Fuubar
--color