mno-enterprise-api 3.1.4 → 3.2.0

data/spec/controllers/mno_enterprise/jpi/v1/app_questions_controller_spec.rb

@@ -0,0 +1,80 @@
+require 'rails_helper'
+
+module MnoEnterprise
+  describe Jpi::V1::AppQuestionsController, type: :controller do
+    include MnoEnterprise::TestingSupport::JpiV1TestHelper
+    render_views
+    routes { MnoEnterprise::Engine.routes }
+    before { request.env["HTTP_ACCEPT"] = 'application/json' }
+
+
+    #===============================================
+    # Assignments
+    #===============================================
+    let(:user) { build(:user) }
+    before { api_stub_for(get: "/users/#{user.id}", response: from_api(user)) }
+    before { sign_in user }
+
+    let(:app) { build(:app) }
+    let(:question_answer_1) { build(:app_answer) }
+    let(:question_answer_2) { build(:app_answer) }
+    let(:app_question) { build(:app_question, answers: [question_answer_1, question_answer_2]) }
+    let(:expected_hash_for_answer_1) do
+      attrs = %w(id description status user_id user_name organization_id organization_name app_id question_id app_name user_admin_role edited edited_by_name edited_by_admin_role edited_by_id)
+      question_answer_1.attributes.slice(*attrs).merge({'created_at' => question_answer_1.created_at.as_json, 'updated_at' => question_answer_1.updated_at.as_json})
+    end
+    let(:expected_hash_for_answer_2) do
+      attrs = %w(id description status user_id user_name organization_id organization_name app_id question_id app_name user_admin_role edited edited_by_name edited_by_admin_role edited_by_id)
+      question_answer_2.attributes.slice(*attrs).merge({'created_at' => question_answer_2.created_at.as_json, 'updated_at' => question_answer_2.updated_at.as_json})
+    end
+    let(:expected_array_for_answers) { [expected_hash_for_answer_1, expected_hash_for_answer_2] }
+    let(:expected_hash_for_question) do
+      attrs = %w(id description status user_id user_name organization_id organization_name app_id app_name user_admin_role answers edited edited_by_name edited_by_admin_role edited_by_id)
+      app_question.attributes.slice(*attrs).merge({'created_at' => app_question.created_at.as_json, 'updated_at' => app_question.updated_at.as_json, 'answers' => expected_array_for_answers})
+    end
+    let(:expected_hash_for_questions) do
+      {
+        'app_questions' => [expected_hash_for_question],
+      }
+    end
+
+    before do
+      api_stub_for(get: "/apps/#{app.id}", response: from_api(app))
+    end
+
+    describe 'GET #index' do
+
+      before do
+        api_stub_for(get: "/app_questions?filter[reviewable_id]=#{app.id}", response: from_api([app_question]))
+      end
+
+      subject { get :index, id: app.id }
+
+      it_behaves_like "jpi v1 protected action"
+
+      it_behaves_like "a paginated action"
+
+      it 'renders the list of reviews' do
+        subject
+        expect(JSON.parse(response.body)).to eq(expected_hash_for_questions)
+      end
+    end
+
+    describe 'POST #create', focus: true do
+      let(:params) { {organization_id: 1, description: 'A Review', foo: 'bar'} }
+
+      before do
+        api_stub_for(post: "/app_questions", response: from_api(app_question))
+        api_stub_for(get: "/app_questions/#{app_question.id}", response: from_api(app_question))
+      end
+
+      subject { post :create, id: app.id, app_question: params }
+
+      it_behaves_like "jpi v1 protected action"
+
+      it 'renders the new review' do
+        expect(JSON.parse(subject.body)).to include('app_question' => expected_hash_for_question)
+      end
+    end
+  end
+end

data/spec/controllers/mno_enterprise/jpi/v1/app_reviews_controller_spec.rb

@@ -0,0 +1,107 @@
+require 'rails_helper'
+
+module MnoEnterprise
+  describe Jpi::V1::AppReviewsController, type: :controller do
+    include MnoEnterprise::TestingSupport::JpiV1TestHelper
+    render_views
+    routes { MnoEnterprise::Engine.routes }
+    before { request.env["HTTP_ACCEPT"] = 'application/json' }
+
+
+    #===============================================
+    # Assignments
+    #===============================================
+    let(:user) { build(:user) }
+    before { api_stub_for(get: "/users/#{user.id}", response: from_api(user)) }
+    before { sign_in user }
+
+    let(:app) { build(:app) }
+    let(:app_review) { build(:app_review) }
+    let(:expected_hash_for_review) do
+      attrs = %w(id rating description status user_id user_name organization_id organization_name app_id app_name json.user_admin_role user_admin_role edited edited_by_name edited_by_admin_role edited_by_id)
+      app_review.attributes.slice(*attrs).merge({'created_at' => app_review.created_at.as_json, 'updated_at' => app_review.updated_at.as_json})
+    end
+    let(:expected_hash_for_reviews) do
+      {
+        'app_reviews' => [expected_hash_for_review],
+      }
+    end
+
+    before do
+      api_stub_for(get: "/apps/#{app.id}", response: from_api(app))
+    end
+
+    describe 'GET #index' do
+
+      before do
+        api_stub_for(get: "/app_reviews?filter[reviewable_id]=#{app.id}", response: from_api([app_review]))
+      end
+
+      subject { get :index, id: app.id }
+
+      it_behaves_like "jpi v1 protected action"
+
+      it_behaves_like "a paginated action"
+
+      it 'renders the list of reviews' do
+        subject
+        expect(JSON.parse(response.body)).to eq(expected_hash_for_reviews)
+      end
+    end
+
+    describe 'POST #create', focus: true do
+      let(:params) { {organization_id: 1, description: 'A Review', rating: 5, foo: 'bar'} }
+      let(:app_review) { build(:app_review) }
+
+      before do
+        api_stub_for(post: "/app_reviews", response: from_api(app_review))
+        api_stub_for(get: "/app_reviews/#{app_review.id}", response: from_api(app_review))
+      end
+
+      subject { post :create, id: app.id, app_review: params }
+
+      it_behaves_like "jpi v1 protected action"
+
+      it 'renders the new review' do
+        expect(JSON.parse(subject.body)).to include('app_review' => expected_hash_for_review)
+      end
+
+      it 'renders the new average rating' do
+        expect(JSON.parse(subject.body)).to include('average_rating' => app.average_rating)
+      end
+    end
+
+    describe 'PATCH #update', focus: true do
+      let(:params) { {description: 'A Review 2', rating: 1} }
+      let(:app_review) { build(:app_review, user_id: user.id) }
+
+      before do
+        api_stub_for(put: "/app_reviews/#{app_review.id}", response: from_api(app_review))
+        api_stub_for(get: "/app_reviews/#{app_review.id}", response: from_api(app_review))
+      end
+
+      subject { put :update, id: app.id, review_id: app_review.id, app_review: params }
+
+      it 'renders the new review' do
+        expect(JSON.parse(subject.body)).to include('app_review' => expected_hash_for_review)
+        expect(JSON.parse(subject.body)).to include('average_rating' => app.average_rating)
+      end
+    end
+
+    describe 'DELETE #destroy', focus: true do
+      let(:app_review) { build(:app_review, user_id: user.id) }
+
+      before do
+        api_stub_for(delete: "/app_reviews/#{app_review.id}", response: from_api(app_review))
+        api_stub_for(get: "/app_reviews/#{app_review.id}", response: from_api(app_review))
+      end
+
+      subject { delete :destroy, id: app.id, review_id: app_review.id }
+
+      it 'renders the new review' do
+        expect(JSON.parse(subject.body)).to include('app_review' => expected_hash_for_review)
+        expect(JSON.parse(subject.body)).to include('average_rating' => app.average_rating)
+      end
+    end
+  end
+end

data/spec/controllers/mno_enterprise/jpi/v1/current_users_controller_spec.rb

@@ -26,6 +26,8 @@ module MnoEnterprise
           'created_at' => res.created_at ? res.created_at.iso8601 : nil,
           'company' => res.company,
           'phone' => res.phone,
+          'api_secret' => res.api_secret,
+          'api_key' => res.api_key,
           'phone_country_code' => res.phone_country_code,
           'country_code' => res.geo_country_code || 'US',
           'website' => res.website,
@@ -54,13 +56,15 @@ module MnoEnterprise
               'token' => res.deletion_request.token
           }
         end
+
+        hash['kpi_enabled'] = !!res.kpi_enabled
       end
 
       hash
     end
 
     # Stub user retrieval
-    let!(:user) { build(:user, :with_deletion_request, :with_organizations) }
+    let!(:user) { build(:user, :with_deletion_request, :with_organizations, :kpi_enabled) }
     before { api_stub_for(get: "/users/#{user.id}", response: from_api(user)) }
 
     describe "GET #show" do
@@ -111,6 +115,17 @@ module MnoEnterprise
       end
     end
 
+    describe 'PUT #register_developer' do
+      before { api_stub_for(put: "/users/#{user.id}", response: from_api(user)) }
+      before { sign_in user }
+      subject { put :register_developer}
+
+      describe 'logged in' do
+        before { subject }
+        it { expect(response).to be_success }
+      end
+    end
+
     describe 'PUT #update_password' do
       let(:attrs) { {current_password: 'password', password: 'blablabla', password_confirmation: 'blablabla'} }
       before { api_stub_for(put: "/users/#{user.id}", response: from_api(user)) }

data/spec/controllers/mno_enterprise/jpi/v1/impac/alerts_controller_spec.rb

@@ -0,0 +1,82 @@
+require 'rails_helper'
+
+module MnoEnterprise
+  describe Jpi::V1::Impac::AlertsController, type: :controller do
+    include MnoEnterprise::TestingSupport::JpiV1TestHelper
+    render_views
+    routes { MnoEnterprise::Engine.routes }
+    before { request.env["HTTP_ACCEPT"] = 'application/json' }
+
+    # Stub ability
+    let!(:ability) { stub_ability }
+    before { allow(ability).to receive(:can?).with(any_args).and_return(true) }
+
+    # Stub user and user call
+    let!(:user) { build(:user) }
+    before { api_stub_for(get: "/users/#{user.id}", response: from_api(user)) }
+    before { sign_in user }
+
+    let(:kpi) { build(:impac_kpi) }
+    let(:alert) { build(:impac_alert, kpi: kpi) }
+    let(:alert_hash) { from_api(alert)[:data].except(:kpi) }
+
+    describe 'GET #index' do
+      before { api_stub_for(get: "/users/#{user.id}/alerts", response: from_api([alert])) }
+      subject { get :index }
+    end
+
+    describe 'POST #create' do
+      before { api_stub_for(get: "/kpis/#{kpi.id}", response: from_api(kpi)) }
+      before { api_stub_for(post: "/users/#{user.id}/alerts", response: from_api(alert)) }
+      before { api_stub_for(get: "/users/#{user.id}/alerts", response: from_api([])) }
+
+      subject { post :create, kpi_id: kpi.id, alert: alert_hash }
+
+      it_behaves_like "jpi v1 authorizable action"
+
+      it "creates and assigns the alert" do
+        subject
+        expect(assigns(:alert)).to eq(alert)
+      end
+
+      it "attaches the alert to the kpi" do
+        subject
+        expect(assigns(:alert).kpi).to eq(kpi)
+      end
+
+      it { subject; expect(response.code).to eq('200') }
+    end
+
+    describe 'PUT #update' do
+      let(:update_alert_hash) { {title: 'test', webhook: 'test', sent: true, forbidden: 'test'} }
+      let(:updated_alert) { build(:impac_alert, kpi: kpi, title: 'test', webhook: 'test', sent: true) }
+
+      before { api_stub_for(get: "/alerts/#{alert.id}", response: from_api(alert)) }
+      before { api_stub_for(put: "/alerts/#{alert.id}", response: from_api(updated_alert)) }
+
+      subject { put :update, id: alert.id, alert: update_alert_hash }
+
+      it_behaves_like "jpi v1 authorizable action"
+
+      it "assigns the alert" do
+        subject
+        expect(assigns(:alert)).to eq(updated_alert)
+      end
+
+      it { subject; expect(response.code).to eq('200') }
+    end
+
+    describe 'DELETE #destroy' do
+      before { api_stub_for(get: "/alerts/#{alert.id}", response: from_api(alert)) }
+      before { api_stub_for(get: "/kpis/#{kpi.id}", response: from_api(kpi)) }
+      before { api_stub_for(delete: "/alerts/#{alert.id}", response: from_api([])) }
+
+      subject { delete :destroy, id: alert.id }
+
+      it_behaves_like "jpi v1 authorizable action"
+
+      it { subject; expect(response.code).to eq('200') }
+      it { subject; expect(JSON.parse(response.body)).to eq({"deleted" => {"service" => alert.service}}) }
+    end
+  end
+end

data/spec/controllers/mno_enterprise/jpi/v1/impac/kpis_controller_spec.rb

@@ -17,18 +17,76 @@ module MnoEnterprise
     before { sign_in user }
 
     let(:dashboard) { build(:impac_dashboard) }
+
+    # TODO KPI DISABLED TEST CASES
+
+    # Stub the dashboard owner
     before { allow_any_instance_of(MnoEnterprise::Impac::Dashboard).to receive(:owner).and_return(user) }
-    before { api_stub_for(get: "/dashboards/#{dashboard.id}", response: from_api(dashboard)) }
 
-    let(:kpi) { build(:impac_kpi, dashboard: dashboard) }
+    let(:kpi_targets) { { evolution: [{max: "20"}] } }
+    let(:kpi) { build(:impac_kpi, dashboard: dashboard, targets: kpi_targets) }
     let(:kpi_hash) { from_api(kpi)[:data].except(:dashboard) }
 
-    before { api_stub_for(post: "/dashboards/#{dashboard.id}/kpis", response: from_api(kpi)) }
-    before { api_stub_for(get: "/dashboards/#{dashboard.id}/kpis", response: from_api([])) }
+    let(:alert) { build(:impac_alert, kpi: kpi) }
+    let(:alerts_hashes) { [from_api(alert)[:data]] }
+
+    describe 'GET index' do
+      let(:params) { { 'metadata' => {'organization_ids' => ['some_id']}, 'opts' => {'some' => 'opts'} } }
+      subject { get :index, metadata: params['metadata'], opts: params['opts'] }
 
+      let(:impac_available_kpis) do
+        [
+          {"name"=>"Debtor Due Days", "endpoint"=>"invoicing/due_days/debtor", "watchables"=>["max", "average"], "attachables"=>nil, "target_placeholders"=>{"max"=>{"mode"=>"max", "value"=>90, "unit"=>"days"}, "average"=>{"mode"=>"max", "value"=>30, "unit"=>"days"}}},
+          {"name"=>"Account Balance", "endpoint"=>"accounting/balance", "watchables"=>["balance"], "attachables"=>["accounts/balance"], "target_placeholders"=>{"balance"=>{"mode"=>"min", "value"=>15000, "unit"=>"currency"}}}
+        ]
+      end
+
+      let(:expected_result) do
+        {
+          "kpis" => [
+            {"name"=>"Debtor Due Days Max", "endpoint"=>"invoicing/due_days/debtor", "watchables"=>["max"], "attachables"=>nil, "target_placeholders"=>{"max"=>{"mode"=>"max", "value"=>90, "unit"=>"days"}}},
+            {"name"=>"Debtor Due Days Average", "endpoint"=>"invoicing/due_days/debtor", "watchables"=>["average"], "attachables"=>nil, "target_placeholders"=>{"average"=>{"mode"=>"max", "value"=>30, "unit"=>"days"}}},
+            {"name"=>"Account Balance", "endpoint"=>"accounting/balance", "watchables"=>["balance"], "attachables"=>["accounts/balance"], "target_placeholders"=>{"balance"=>{"mode"=>"min", "value"=>15000, "unit"=>"currency"}}},
+          ]
+        }
+      end
+
+      let(:auth) { { username: 'username', password: 'password' } }
+      before { allow(MnoEnterprise::ImpacClient).to receive(:send_get).with('/api/v2/kpis', params, basic_auth: auth).and_return('kpis' => impac_available_kpis) }
+      before { allow(MnoEnterprise).to receive(:tenant_id).and_return(auth[:username]) }
+      before { allow(MnoEnterprise).to receive(:tenant_key).and_return(auth[:password]) }
+
+      it { subject; expect(response.code).to eq('200') }
+
+      it "successfully discovers and customises available kpis" do
+        expect(MnoEnterprise::ImpacClient).to receive(:send_get)
+        subject
+        expect(JSON.parse(response.body)).to eq(expected_result)
+      end
+
+      context "when impac api request raises an error" do
+        before { allow(MnoEnterprise::ImpacClient).to receive(:send_get).and_raise }
+
+        it "rescues responding with an error message" do
+          subject
+          expect(JSON.parse(response.body)).to include('message')
+        end
+      end
+    end
 
     describe 'POST #create' do
       subject { post :create, dashboard_id: dashboard.id, kpi: kpi_hash }
+      let (:kpi_targets) { {} }
+
+      before do
+        api_stub_for(get: "/dashboards/#{dashboard.id}", response: from_api(dashboard))
+        api_stub_for(post: "/dashboards/#{dashboard.id}/kpis", response: from_api(kpi))
+        api_stub_for(get: "/dashboards/#{dashboard.id}/kpis", response: from_api([]))
+        api_stub_for(get: "/kpis/#{kpi.id}", response: from_api(kpi)) # kpi.reload
+        # TODO: this call should not happen as alerts should be wrapped into the kpi object
+        api_stub_for(get: "/kpis/#{kpi.id}/alerts", response: from_api(alerts_hashes))
+      end
+
       it_behaves_like "jpi v1 authorizable action"
 
       it ".dashboard retrieves the correct dashboard" do
@@ -41,17 +99,35 @@ module MnoEnterprise
         expect(assigns(:kpi)).to eq(kpi)
       end
 
+      context "when there are kpi targets" do
+        let(:kpi_targets) { { evolution: [{max: "20"}] } }
+
+        before do
+          api_stub_for(post: "/users/#{user.id}/alerts", response: from_api(alert))
+          api_stub_for(get: "/users/#{user.id}/alerts", response: from_api({}))
+        end
+
+        it "creates kpi alerts" do
+          subject
+          expect(assigns(:kpi).alerts).to eq([alert])
+          expect(response.code).to eq('200')
+        end
+      end
+
       it { subject; expect(response.code).to eq('200') }
-      it { subject; expect(JSON.parse(response.body)).to eq(kpi_hash) }
     end
 
     describe 'PUT #update' do
       let(:kpi_hash) { from_api(kpi)[:data].except(:dashboard).merge(element_watched: 'New Watchable') }
+      let(:params) { {} }
 
-      subject { put :update, id: kpi.id, kpi: kpi_hash }
+      subject { put :update, id: kpi.id, kpi: kpi_hash.merge(params) }
 
-      before { api_stub_for(get: "/kpis/#{kpi.id}", response: from_api(kpi)) }
-      before { api_stub_for(put: "/kpis/#{kpi.id}", response: kpi_hash) }
+      before do
+        api_stub_for(get: "/kpis/#{kpi.id}", response: from_api(kpi))
+        api_stub_for(put: "/kpis/#{kpi.id}", response: kpi_hash)
+        api_stub_for(get: "/kpis/#{kpi.id}/alerts", response: from_api(alerts_hashes))
+      end
 
       before { kpi.save }
 
@@ -60,10 +136,71 @@ module MnoEnterprise
       it "updates the kpi" do
         subject
         expect(assigns(:kpi).element_watched).to eq('New Watchable')
+        expect(response.code).to eq('200')
       end
 
-      it { subject; expect(response.code).to eq('200') }
-      it { subject; expect(JSON.parse(response.body)).to eq(kpi_hash) }
+      context "target set for the first time" do
+        let(:kpi_targets) { nil }
+        let(:params) { { targets: {evolution: [{max:'20'}]} } }
+
+        before do
+          api_stub_for(post: "/users/#{user.id}/alerts", response: from_api(alert))
+          api_stub_for(get: "/users/#{user.id}/alerts", response: from_api({}))
+        end
+
+        it "creates an alert" do
+          subject
+          expect(assigns(:kpi).alerts).to eq([alert])
+          expect(response.code).to eq('200')
+        end
+      end
+
+      context "when targets have changed" do
+        let(:alert) { build(:impac_alert, kpi: kpi, sent: true) }
+        let(:params) { { targets: {evolution: [{max:'30'}]} } }
+
+        before { api_stub_for(put: "/alerts/#{alert.id}", response: from_api({})) }
+
+        it "updates the sent status of all the kpi's alerts" do
+          subject
+          expect(assigns(:kpi).alerts).to eq([alert])
+          expect(response.code).to eq('200')
+        end
+      end
+
+      context "when a kpi has no targets, nor is being updated with any" do
+        let(:kpi_targets) { nil }
+        let(:params) { { targets: {} } }
+
+        before { api_stub_for(delete: "/alerts/#{alert.id}", response: from_api({})) }
+
+        it "destroys the kpi's alerts" do
+          subject
+          expect(response.code).to eq('200')
+        end
+      end
+
+      context "when no targets are given / targets are nil" do
+        let(:kpi) { build(:impac_kpi, dashboard: dashboard, targets: kpi_targets, settings: { currency: 'GBP' }) }
+        let(:params) { { targets: nil } }
+
+        it "does not remove the kpi targets" do
+          subject
+          expect(assigns(:kpi).targets).to eq(kpi_targets.deep_stringify_keys)
+          expect(response.code).to eq('200')
+        end
+      end
+
+      context "when no extra_params are given / extra_params are nil" do
+        let(:kpi) { build(:impac_kpi, dashboard: dashboard, targets: kpi_targets, extra_params: ['some-param'], settings: { currency: 'GBP' }) }
+        let(:params) { { extra_params: nil } }
+
+        it "does not remove the kpi extra_params" do
+          subject
+          expect(assigns(:kpi).extra_params).to eq(['some-param'])
+          expect(response.code).to eq('200')
+        end
+      end
     end
 
     describe 'DELETE #destroy' do