dune-api 1.0.1

data/spec/controllers/neighborly/api/v1/sessions_controller_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::SessionsController do
+  routes                { Dune::Api::Engine.routes }
+  let!(:user)           { FactoryGirl.create(:user) }
+  let(:parsed_response) { JSON.parse(response.body) }
+
+  describe '#create' do
+    it 'responds with 401 when requested with invalid email/password combination' do
+      post :create, email: user.email, password: 'wrong-password'
+      expect(response.status).to eql(401)
+    end
+
+    it 'responds with 401 when requested with invalid email' do
+      post :create, email: 'wrong-email', password: 'wrong-password'
+      expect(response.status).to eql(401)
+    end
+
+    it 'responds with 400 when requested with no email' do
+      post :create, password: 'right-password'
+      expect(response.status).to eql(400)
+    end
+
+    it 'responds with 400 when requested with no password' do
+      post :create, email: user.email
+      expect(response.status).to eql(400)
+    end
+
+    it 'responds with 201 when requested with valid email and password combination' do
+      post :create, email: user.email, password: 'right-password'
+      expect(response.status).to eql(201)
+    end
+
+    it 'returns session data when requested with valid email and password combination' do
+      post :create, email: user.email, password: 'right-password'
+      expect(parsed_response['access_token']).to eql(user.get_access_token)
+      expect(parsed_response['user_id']).to      eql(user.id)
+    end
+  end
+
+  describe '#destroy', authorized: true do
+    let(:do_request) { delete :destroy }
+
+    context 'when access_token is provided' do
+      context 'and is valid' do
+        before do
+          request.env['HTTP_AUTHORIZATION'] = "Token token=#{valid_access_token.code}"
+        end
+        let(:valid_access_token) { FactoryGirl.create(:access_token, user: user) }
+
+        it 'responds with 200' do
+          expect(response.status).to eql(200)
+        end
+
+        it 'expires given access_token' do
+          delete :destroy
+          expect(valid_access_token.reload).to be_expired
+        end
+
+        it 'renders empty json' do
+          delete :destroy
+          expect(parsed_response).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/controllers/neighborly/api/v1/tags_controller_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::TagsController do
+  routes { Dune::Api::Engine.routes }
+  let(:parsed_response) { JSON.parse(response.body) }
+
+  describe '#index', authorized: true do
+    let!(:tag)       { FactoryGirl.create(:tag) }
+    let(:do_request) { get :index, format: :json }
+
+    it_behaves_like 'paginating results'
+
+    it 'responds with 200' do
+      do_request
+      expect(response.status).to eql(200)
+    end
+
+    it 'has a top level element called tags' do
+      do_request
+      expect(parsed_response.fetch('tags')).to be_a(Array)
+    end
+
+    it 'responds with data of tags' do
+      do_request
+      expect(
+        parsed_response.fetch('tags').first
+      ).to have_key('id')
+    end
+
+    describe 'filter by popular' do
+      let!(:popular) { FactoryGirl.create(:tag_popular) }
+
+      it 'accepts truthy popular parameter' do
+        get :index, format: :json, popular: '1'
+        response_ids = parsed_response.fetch('tags').map { |t| t['id'] }
+        expect(response_ids).to eql([popular.id])
+      end
+
+      it 'skip any filtering for popular when receiving falsy value' do
+        get :index, format: :json, popular: '0'
+        response_ids = parsed_response.fetch('tags').map { |t| t['id'] }
+        expect(response_ids).to eql(Tag.pluck(:id))
+      end
+    end
+  end
+
+  describe '#create', authorized: true, admin: true do
+    let(:do_request) { post :create, tag: { name: 'foobar', visible: true }, format: :json }
+
+    context 'on success' do
+      it 'returns a created http status' do
+        do_request
+        expect(response.status).to eq(201)
+      end
+
+      it 'returns a json' do
+        do_request
+
+        expect(parsed_response.count).to eq(1)
+        expect(parsed_response['tag']['name']).to eq('foobar')
+        expect(parsed_response['tag']['visible']).to eq(true)
+      end
+    end
+
+    context 'on failure' do
+      let(:do_request) { post :create, tag: { }, format: :json }
+
+      it 'returns a unprocessable entity http status' do
+        do_request
+        expect(response.status).to eq(422)
+      end
+
+      it 'returns a json with errors' do
+        do_request
+
+        expect(parsed_response.count).to eq(1)
+        expect(parsed_response['errors']['name']).not_to be_empty
+      end
+    end
+  end
+
+  describe '#update', authorized: true, admin: true do
+    let!(:tag) { FactoryGirl.create(:tag) }
+
+    let(:do_request) do
+      put :update,
+          id: tag,
+          tag: { name: 'foobar', visible: true }, format: :json
+    end
+
+    context 'on success' do
+      it 'returns a no content http status' do
+        do_request
+        expect(response.status).to eq(204)
+      end
+    end
+
+    context 'on failure' do
+      let(:do_request) { put :update, id: tag, tag: { name: '' }, format: :json }
+
+      it 'returns a unprocessable entity http status' do
+        do_request
+        expect(response.status).to eq(422)
+      end
+
+      it 'returns a json with errors' do
+        do_request
+
+        expect(parsed_response.count).to eq(1)
+        expect(parsed_response['errors']['name']).not_to be_empty
+      end
+    end
+  end
+
+  describe '#show', authorized: true do
+    let!(:tag)       { FactoryGirl.create(:tag) }
+    let(:do_request) { get :show, id: tag, format: :json }
+
+    it 'returns a success http status' do
+      do_request
+      expect(response.status).to eq(200)
+    end
+
+    it 'returns a json' do
+      do_request
+
+      expect(parsed_response.count).to eq(1)
+      expect(parsed_response['tag']['name']).to eq(tag.name)
+      expect(parsed_response['tag']['visible']).to eq(tag.visible)
+    end
+  end
+
+  describe '#destroy', authorized: true, admin: true do
+    let!(:tag)       { FactoryGirl.create(:tag) }
+    let(:do_request) { delete :destroy, id: tag, format: :json }
+
+    it 'returns a success http status' do
+      do_request
+      expect(response.status).to eq(204)
+      expect { tag.reload }.to raise_error
+    end
+  end
+end

data/spec/controllers/neighborly/api/v1/users_controller_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::UsersController do
+  routes                { Dune::Api::Engine.routes }
+  let(:parsed_response) { JSON.parse(response.body) }
+  let(:users_returned) do
+    parsed_response.fetch('users').map { |t| t['id'] }
+  end
+
+  describe '#index', authorized: true, admin: true do
+    let(:do_request) { get :index, format: :json }
+
+    it_behaves_like 'paginating results'
+
+    it 'filters by query' do
+      FactoryGirl.create(:user, name: 'Ordinary user')
+      _user = FactoryGirl.create(:user, name: 'Wonderful user')
+      get :index, format: :json, query: 'wonderful'
+      expect(users_returned).to eql([_user.id])
+    end
+  end
+
+  describe '#show', authorized: true do
+    let(:do_request) { get :show, id: user.id, format: :json }
+
+    it 'responds with 200' do
+      do_request
+      expect(response.status).to eql(200)
+    end
+
+    it 'has a top level element called user' do
+      do_request
+      expect(parsed_response.fetch('user')).to be_a(Hash)
+    end
+
+    it 'responds with data of the given user' do
+      do_request
+      expect(
+        parsed_response.fetch('user')
+      ).to have_key('id')
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,78 @@
+FactoryGirl.define do
+  factory :access_token, class: 'Dune::Api::AccessToken' do
+    user
+  end
+
+  factory :category do
+    name_pt { "category-#{rand}" }
+  end
+
+  factory :project, class: 'Dune::Api::Project' do
+    about    'a-big-text-about-the-project'
+    goal     10_000
+    headline 'attractive-headline'
+    location 'New York, NY'
+    name     'z-project'
+    state    :online
+    user
+    category
+  end
+
+  factory :investment do
+    project { create(:project, state: 'online') }
+    user
+    confirmed_at Time.now
+    value 10.00
+    state 'confirmed'
+    credits false
+  end
+
+  factory :tag do
+    name    { "subject-#{rand}" }
+    visible true
+  end
+
+  factory :tag_popular, parent: :tag do
+    after(:create) do |resource, evaluator|
+      projects = create_list(:project, 4, state: :online)
+      projects.map do |project|
+        project.tags << resource
+        project.save
+      end
+    end
+  end
+
+  factory :user do
+    name         'Joãozinho'
+    password     'right-password'
+    email        { "person#{rand}@example.com" }
+    confirmed_at { Time.now }
+  end
+
+  factory :channel do
+    user { create(:user, profile_type: 'channel') }
+    name 'Test'
+    description 'Lorem Ipsum'
+    sequence(:permalink) { |n| "#{n}-test-page" }
+    state 'online'
+  end
+
+  factory :channel_member do
+    user
+    channel
+  end
+
+  factory :press_asset do
+    title 'Lorem'
+    url 'http://lorem.com'
+    image File.open("#{Dune::Api::Engine.root}/spec/fixtures/image.png")
+  end
+
+  factory :reward do
+    project
+    title 'Awesome Foo Bar'
+    minimum_value 10.00
+    description 'Foo bar'
+    days_to_delivery 10
+  end
+end

data/spec/models/neighborly/api/investment_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Dune::Api::Investment do
+  describe '.between_values' do
+    it 'returns the investments with value between 15 and 20' do
+      FactoryGirl.create(:investment, value: 10)
+      FactoryGirl.create(:investment, value: 15)
+      FactoryGirl.create(:investment, value: 20)
+      FactoryGirl.create(:investment, value: 21)
+
+      expect(described_class.between_values(15, 20).size).to eq 2
+    end
+
+    it 'removes comma and transform it to float' do
+      expect(described_class).to receive(:where).with('value between ? and ?', 1000.0, 2000.4)
+      described_class.between_values('1,000', '2,000.40')
+    end
+  end
+
+  describe '.by_project_id' do
+    let(:first_project)  { FactoryGirl.create(:project, state: 'online') }
+    let(:second_project) { FactoryGirl.create(:project, state: 'online') }
+
+    before do
+      FactoryGirl.create(:investment, value: 10, project: first_project)
+      FactoryGirl.create(:investment, value: 10, project: second_project)
+    end
+
+    it 'returns the investments from the first project' do
+      expect(described_class.by_project_id(first_project.id).size).to eq 1
+    end
+  end
+end

data/spec/models/neighborly/api/user_concern_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe User do
+  describe 'get_access_token' do
+    subject { FactoryGirl.create(:user) }
+
+    context 'when the user does not have an access token' do
+      it 'creates an access token and returns its code' do
+        expect {
+          subject.get_access_token
+        }.to change(subject.access_tokens.reload, :count).by(1)
+      end
+
+      it 'returns the last' do
+        expect(subject.get_access_token).to eql(subject.access_tokens.last.code)
+      end
+    end
+
+    context 'when the user already has one access token' do
+      before { subject.access_tokens.create }
+
+      it 'skips creation of a new' do
+        expect {
+          subject.get_access_token
+        }.to_not change(subject.access_tokens.reload, :count)
+      end
+
+      it 'returns the last' do
+        expect(subject.get_access_token).to eql(subject.access_tokens.last.code)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+require 'factories'
+
+ENGINE_RAILS_ROOT=File.join(File.dirname(__FILE__), '../')
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(ENGINE_RAILS_ROOT, "spec/support/**/*.rb")].each {|f| require f }
+
+require 'sidekiq/testing'
+Sidekiq::Testing.fake!
+
+Geocoder.configure(lookup: :test)
+Geocoder::Lookup::Test.set_default_stub(
+  [
+    {
+      'latitude'     => 40.7143528,
+      'longitude'    => -74.0059731,
+      'address'      => 'New York, NY, USA',
+      'state'        => 'New York',
+      'state_code'   => 'NY',
+      'country'      => 'United States',
+      'country_code' => 'US'
+    }
+  ]
+)
+
+RSpec.configure do |config|
+  config.include RSpec::Rails::ControllerExampleGroup,
+     file_path: %r(spec/controllers)
+  config.use_transactional_fixtures = true
+
+  # Stubs required from the main application
+  config.before(:each) do
+    double(::UserObserver)
+    allow_any_instance_of(UserObserver).to receive(:after_create)
+    allow_any_instance_of(UserObserver).to receive(:after_save)
+  end
+end