dune-api 1.0.1

data/lib/dune/api.rb

@@ -0,0 +1,12 @@
+require 'dune/api/engine'
+require 'dune/api/paginated_controller'
+require 'dune/api/version'
+require 'active_model_serializers'
+require 'has_scope'
+require 'kaminari'
+require 'pundit'
+
+module Dune
+  module Api
+  end
+end

data/lib/dune/api/engine.rb

@@ -0,0 +1,11 @@
+module Dune
+  module Api
+    class Engine < ::Rails::Engine
+      isolate_namespace Dune::Api
+
+      config.to_prepare do
+        ::User.send(:include, Dune::Api::UserConcern)
+      end
+    end
+  end
+end

data/lib/dune/api/paginated_controller.rb

@@ -0,0 +1,19 @@
+module Dune
+  module Api
+    module PaginatedController
+      extend ActiveSupport::Concern
+
+      included do
+        has_scope :page, default: 1
+      end
+
+      def respond_with_pagination(collection)
+        render json: collection, meta: {
+          page:        collection.current_page,
+          total:       collection.total_count,
+          total_pages: collection.total_pages
+        }
+      end
+    end
+  end
+end

data/lib/dune/api/version.rb

@@ -0,0 +1,5 @@
+module Dune
+  module Api
+    VERSION = '1.0.1'
+  end
+end

data/spec/constraints/neighborly/api/api_constraint_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Dune::Api::ApiConstraint do
+  let(:request) { double :request }
+
+  describe '#matches?' do
+    let(:revision) { 1 }
+
+    def header_for_revision(revision)
+      "revision=#{revision}"
+    end
+
+    context 'when default is false' do
+      subject(:constraint) { described_class.new(revision: revision) }
+
+
+      it 'matches requests including the versioned vendor mime type' do
+        headers = { accept: header_for_revision(revision) }
+        allow(request).to receive(:headers).and_return(headers)
+
+        expect(constraint.matches?(request)).to eq true
+      end
+
+      it 'does not match requests for other revisions' do
+        headers = { accept: header_for_revision(revision + 1) }
+        allow(request).to receive(:headers).and_return(headers)
+
+        expect(constraint.matches?(request)).to eq false
+      end
+    end
+
+    context 'when default is true' do
+      subject(:constraint) { described_class.new(revision: revision, default: true) }
+
+      it 'matches requests including the versioned vendor mime type' do
+        headers = { accept: header_for_revision(revision) }
+        allow(request).to receive(:headers).and_return(headers)
+
+        expect(constraint.matches?(request)).to eq true
+      end
+
+      it 'matches requests when default is true' do
+        headers = { accept: header_for_revision(revision + 1) }
+        allow(request).to receive(:headers).and_return(headers)
+
+        expect(constraint.matches?(request)).to eq true
+      end
+    end
+  end
+end

data/spec/controllers/neighborly/api/v1/channels/members_controller_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::Channels::MembersController do
+  routes                { Dune::Api::Engine.routes }
+  let(:parsed_response) { JSON.parse(response.body) }
+  let!(:channel)        { FactoryGirl.create(:channel) }
+  let!(:member)         { FactoryGirl.create(:channel_member, channel: channel) }
+
+  let(:records_returned) do
+    parsed_response.fetch('users').map { |t| t['id'] }
+  end
+
+  describe '#index', authorized: true, admin: true do
+    let(:do_request) { get :index, channel_id: channel.id, format: :json }
+
+    it 'returns the members list' do
+      do_request
+      expect(records_returned.count).to eq 1
+    end
+  end
+
+  describe '#create', authorized: true, admin: true do
+    let(:new_user) { FactoryGirl.create(:user) }
+
+    let(:do_request) do
+      post :create,
+        channel_id: channel.id,
+        channel_member: { user_id: new_user.id },
+        format: :json
+    end
+
+    it 'creates the record' do
+      expect{ do_request }.to change{ channel.channel_members.count }.from(1).to(2)
+    end
+
+    context 'on success' do
+      it 'returns a success http status' do
+        do_request
+        expect(response.status).to eq(201)
+      end
+
+      it 'returns the user' do
+        do_request
+        expect(parsed_response.fetch('user').fetch('id')).to eq new_user.id
+      end
+    end
+
+    context 'on failure' do
+      let(:do_request) do
+      post :create,
+        channel_id: channel.id,
+        channel_member: { user_id: nil },
+        format: :json
+      end
+
+      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']['user_id']).not_to be_empty
+      end
+    end
+  end
+
+  describe 'destroy', authorized: true, admin: true do
+    let(:do_request) do
+      delete :destroy, id: member.user.id, channel_id: channel.id, format: :json
+    end
+
+    it 'returns a success http status' do
+      do_request
+      expect(response.status).to eq(204)
+      expect{ member.reload }.to raise_error
+    end
+  end
+end
+

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

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::ChannelsController do
+  routes                { Dune::Api::Engine.routes }
+  let(:parsed_response) { JSON.parse(response.body) }
+  let!(:channel)        { FactoryGirl.create(:channel) }
+
+  let(:channels_returned) do
+    parsed_response.fetch('channels').map { |t| t['id'] }
+  end
+
+  describe '#index', authorized: true do
+    let(:do_request) { get :index, format: :json }
+
+    it_behaves_like 'paginating results'
+
+    it 'applies the policy scope' do
+      expect(controller).to receive(:policy_scope).with(Channel).and_call_original
+      do_request
+    end
+
+    it 'filters by query' do
+      FactoryGirl.create(:channel, name: 'Ordinary channel')
+      channel = FactoryGirl.create(:channel, name: 'Wonderful channel')
+      get :index, format: :json, query: 'wonderful'
+      expect(channels_returned).to eql([channel.id])
+    end
+
+    describe 'filter by state' do
+      let!(:draft_channel) do
+        FactoryGirl.create(:channel, state: :draft, user: user)
+      end
+
+      Channel.state_names.each do |state|
+        it "filters by state #{state}" do
+          channel      = FactoryGirl.create(:channel, state: state, user: user)
+          expected_ids = if state.eql?(:draft)
+            [channel.id, draft_channel.id]
+          else
+            [channel.id]
+          end
+
+          get :index, format: :json, state => '1'
+          expect(channels_returned).to include(*expected_ids)
+        end
+      end
+    end
+  end
+
+  describe '#create', authorized: true, admin: true do
+    let(:do_request) do
+      post :create,
+        channel: FactoryGirl.build(:channel).attributes,
+        format: :json
+    end
+
+    it 'creates the record' do
+      expect{ do_request }.to change{ Channel.count }.from(1).to(2)
+    end
+
+    context 'on success' do
+      it 'returns a success http status' do
+        do_request
+        expect(response.status).to eq(201)
+      end
+    end
+
+    context 'on failure' do
+      let(:do_request) do
+        post :create,
+          channel: { name: nil },
+          format: :json
+      end
+
+      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 do
+    let(:user) { channel.user }
+
+    let(:do_request) do
+      put :update,
+        id: channel.id,
+        channel: { name: 'foo bar' },
+        format: :json
+    end
+
+    it 'updates the record' do
+      expect(Channel).to receive(:update)
+        .with(channel.id.to_s, { 'name' => 'foo bar' })
+
+      do_request
+    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) do
+        put :update,
+          id: channel.id,
+          channel: { name: nil },
+          format: :json
+      end
+
+      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(:do_request) { get :show, id: channel.id, format: :json }
+
+    it 'responds with 200' do
+      do_request
+      expect(response.status).to eql(200)
+    end
+
+    it 'has a top level element called channel' do
+      do_request
+      expect(parsed_response.fetch('channel')).to be_a(Hash)
+    end
+
+    it 'responds with data of the given channel' do
+      do_request
+      expect(
+        parsed_response.fetch('channel')
+      ).to have_key('id')
+    end
+  end
+
+  describe 'destroy', authorized: true, admin: true do
+    let(:do_request) { delete :destroy, id: channel.id, format: :json }
+
+    it 'returns a success http status' do
+      do_request
+      expect(response.status).to eq(204)
+      expect{ channel.reload }.to raise_error
+    end
+  end
+
+  [:push_to_draft, :push_to_online].each do |name|
+    describe "#{name}", authorized: true, admin: true do
+      let(:user)       { FactoryGirl.create(:user, admin: true) }
+      let(:channel)    { FactoryGirl.create(:channel, state: 'draft') }
+      let(:do_request) { put name, id: channel.id, format: :json }
+
+      it 'returns a success http status' do
+        do_request
+        expect(response.status).to eq(204)
+      end
+
+      it 'authorizes the resource' do
+        expect(controller).to receive(:authorize).with(channel)
+        do_request
+      end
+
+      it 'calls the state machine helper to change the state' do
+        expect_any_instance_of(Channel).to receive("#{name}!")
+        do_request
+      end
+    end
+  end
+end

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

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Dune::Api::V1::InvestmentsController do
+  routes { Dune::Api::Engine.routes }
+  let!(:investment) { FactoryGirl.create(:investment) }
+
+  let(:investments_returned) do
+    parsed_response.fetch('investments').map { |t| t['id'] }
+  end
+
+  let(:parsed_response) { JSON.parse(response.body) }
+
+  describe '#index', authorized: true, admin: true do
+    let(:do_request) { get :index, format: :json }
+
+    it_behaves_like 'paginating results'
+
+    it 'filters by query' do
+      investment = FactoryGirl.create(:investment, payment_method: 'balanced')
+      FactoryGirl.create(:investment, payment_method: 'paypal')
+      get :index, format: :json, query: 'balanced'
+      expect(investments_returned).to eql([investment.id])
+    end
+
+    describe 'filtering by between_values' do
+      before do
+        @investment_30 = FactoryGirl.create(:investment, value: 30)
+        @investment_35 = FactoryGirl.create(:investment, value: 35)
+        FactoryGirl.create(:investment, value: 40)
+      end
+
+      it 'returns just those investments in the given range' do
+        get :index, format: :json,
+          between_values: {
+            initial: 30,
+            final:   35
+          }
+        expect(investments_returned).to eql([@investment_35.id, @investment_30.id])
+      end
+    end
+
+    describe 'filter by state' do
+      let!(:pending_investment) do
+        FactoryGirl.create(:investment, state: :pending)
+      end
+
+      Investment.state_names.each do |state|
+        it "filters by state #{state}" do
+          investment = FactoryGirl.create(:investment, state: state)
+          expected_ids = if state.eql?(:pending)
+            [investment.id, pending_investment.id]
+          else
+            [investment.id]
+          end
+
+          get :index, format: :json, state => '1'
+          expect(investments_returned).to include(*expected_ids)
+        end
+      end
+    end
+
+    describe 'filter by project id' do
+      let(:first_project)  { FactoryGirl.create(:project, state: 'online') }
+      let(:second_project) { FactoryGirl.create(:project, state: 'online') }
+
+      before do
+        @investment = FactoryGirl.create(:investment, value: 10, project: first_project)
+        FactoryGirl.create(:investment, value: 10, project: second_project)
+      end
+
+      it 'returns just those investments in the given project id' do
+        get :index, project_id: first_project.id, format: :json
+        expect(investments_returned).to eql([@investment.id])
+      end
+    end
+  end
+
+  describe '#show', authorized: true, admin: true do
+    let(:do_request) { get :show, id: investment.id, format: :json }
+
+    it 'responds with 200' do
+      do_request
+      expect(response.status).to eql(200)
+    end
+
+    it 'has a top level element called investment' do
+      do_request
+      expect(parsed_response.fetch('investment')).to be_a(Hash)
+    end
+
+    it 'responds with data of the given investment' do
+      do_request
+      expect(
+        parsed_response.fetch('investment')
+      ).to have_key('id')
+    end
+  end
+
+  describe '#update', authorized: true, admin: true do
+    let(:do_request) do
+      put :update,
+          id: investment.id,
+          investment: { value: 15 },
+          format: :json
+    end
+
+    it 'updates the record' do
+      expect(::Investment).to receive(:update)
+        .with(investment.id.to_s, { 'value' => 15 })
+
+      do_request
+    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) do
+        put :update,
+            id: investment.id,
+            investment: { value: nil },
+            format: :json
+      end
+
+      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']['value']).not_to be_empty
+      end
+    end
+  end
+
+  describe 'destroy', authorized: true, admin: true do
+    let(:do_request) { delete :destroy, id: investment.id, format: :json }
+
+    it 'returns a success http status' do
+      do_request
+      expect(response.status).to eq(204)
+      expect(investment.reload.deleted?).to be_truthy
+    end
+  end
+
+  [:confirm, :pendent, :refund, :hide, :cancel].each do |name|
+    describe "#{name}", authorized: true, admin: true do
+      let(:user)         { FactoryGirl.create(:user, admin: true) }
+      let(:investment) do
+        state = (name == :refund) ? 'confirmed' : 'deleted'
+        FactoryGirl.create(:investment, state: state)
+      end
+      let(:do_request)   { put name, id: investment.id, format: :json }
+
+      it 'returns a success http status' do
+        do_request
+        expect(response.status).to eq(204)
+      end
+
+      it 'authorizes the resource' do
+        expect(controller).to receive(:authorize).with(investment)
+        do_request
+      end
+
+      it 'calls the state machine helper to change the state' do
+        expect_any_instance_of(Investment).to receive("#{name}!")
+        do_request
+      end
+    end
+  end
+end