mno-enterprise-core 3.1.4 → 3.2.0

data/lib/mno_enterprise/testing_support/factories/impac/alerts.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+
+  factory :mno_enterprise_impac_alert, :class => 'Impac::Alert' do
+    factory :impac_alert, class: MnoEnterprise::Impac::Alert do
+
+      sequence(:id) { |n| n }
+      # Mno-hub is sending back a impac_kpi_id, and with Her, the factory objects aren't working so well...
+      # kpi { build(:impac_kpi).attributes }
+      impac_kpi_id 1
+      service "inapp"
+      title "Test Alert"
+      recipients [{id: 1, email: 'test@maestrano.com'}]
+
+      # Properly build the resource with Her
+      initialize_with { new(attributes).tap { |e| e.clear_attribute_changes! } }
+    end
+  end
+end

data/lib/mno_enterprise/testing_support/factories/impac/kpis.rb

@@ -1,17 +1,13 @@
 FactoryGirl.define do
-    
+
   factory :mno_enterprise_impac_kpi, :class => 'Impac::Kpi' do
     factory :impac_kpi, class: MnoEnterprise::Impac::Kpi do
-      
+
       sequence(:id) { |n| n }
       dashboard { build(:impac_dashboard).attributes }
-      endpoint "an/endpoint"
-      element_watched "a_watchable"
-      source "impac"
-      targets {}
-      settings {}
-      extra_params {}
-      
+      endpoint "finance/revenue"
+      element_watched "evolution"
+
       # Properly build the resource with Her
       initialize_with { new(attributes).tap { |e| e.clear_attribute_changes! } }
     end

data/lib/mno_enterprise/testing_support/factories/users.rb

@@ -46,6 +46,10 @@ FactoryGirl.define do
       organizations { [build(:organization).attributes] }
     end
 
+    trait :kpi_enabled do
+      kpi_enabled true
+    end
+
     # Properly build the resource with Her
     initialize_with { new(attributes).tap { |e| e.clear_attribute_changes! } }
   end

data/lib/mno_enterprise/testing_support/jpi_v1_test_helper.rb

@@ -34,6 +34,7 @@ module MnoEnterprise::TestingSupport::JpiV1TestHelper
         sign_in user
         allow(ability).to receive(:can?).with(any_args).and_return(false)
         expect(subject).to_not be_successful
+        expect(subject.code).to eq('403')
       end
     end
 
@@ -46,4 +47,42 @@ module MnoEnterprise::TestingSupport::JpiV1TestHelper
     end
   end
 
+  shared_examples_for "a not found response" do
+    it { expect(subject).to_not be_success }
+    it do
+      subject
+      expect(response.status).to eq(404)
+    end
+  end
+
+  shared_examples_for "a bad request response" do
+    it { expect(subject).to_not be_success }
+    it do
+      subject
+      expect(response.status).to eq(400)
+    end
+  end
+
+  shared_examples_for "a forbidden response" do
+    it { expect(subject).to_not be_success }
+    it do
+      subject
+      expect(response.status).to eq(403)
+    end
+  end
+
+  shared_examples_for "an internal server error response" do
+    it { expect(subject).to_not be_success }
+    it do
+      subject
+      expect(response.status).to eq(500)
+    end
+  end
+
+  shared_examples_for "a paginated action" do
+    it 'adds the pagination metadata' do
+      subject
+      expect(response.headers['X-Total-Count']).to be_a(Fixnum)
+    end
+  end
 end

data/lib/mno_enterprise/testing_support/organizations_shared_helpers.rb

@@ -52,7 +52,8 @@ module MnoEnterprise::TestingSupport::OrganizationsSharedHelpers
     ret = {
         'id' => organization.id,
         'name' => organization.name,
-        'soa_enabled' => organization.soa_enabled
+        'soa_enabled' => organization.soa_enabled,
+        'payment_restriction' => organization.payment_restriction
     }
 
     if admin

data/lib/mno_enterprise/testing_support/shared_examples/jpi_v1_admin.rb

@@ -0,0 +1,38 @@
+module MnoEnterprise::TestingSupport::SharedExamples::JpiV1Admin
+  shared_examples "a jpi v1 admin action" do
+    context "without a signed in user" do
+      before { sign_out('user') }
+
+      it "prevents access" do
+        expect(subject).to_not be_successful
+        expect(subject.code).to eq('401')
+      end
+    end
+
+    context "with a non admin signed in user" do
+      let(:user) { FactoryGirl.build(:user) }
+      before do
+        api_stub_for(get: "/users/#{user.id}", response: from_api(user))
+        sign_in user
+      end
+
+      it "prevents access" do
+        expect(subject).to_not be_successful
+        expect(subject.code).to eq('401')
+      end
+    end
+
+    context "with a signed in admin" do
+      let(:user) { FactoryGirl.build(:user, :admin, :with_organizations) }
+      before do
+        api_stub_for(get: "/users/#{user.id}", response: from_api(user))
+        sign_in user
+      end
+
+      it "authorizes access" do
+        sign_in user
+        expect(subject).to be_successful
+      end
+    end
+  end
+end

data/lib/mno_enterprise/version.rb

@@ -1,3 +1,3 @@
 module MnoEnterprise
-  VERSION = '3.1.4'
+  VERSION = '3.2.0'
 end

data/spec/lib/devise/model/remote_authenticable_spec.rb

@@ -0,0 +1,76 @@
+require "rails_helper"
+
+RSpec.describe Devise::Models::RemoteAuthenticatable < ActiveSupport::TestCase do
+  let(:user) { build(:user, email: 'test@maestrano.com', password: 'oldpass') }
+
+  before do
+    api_stub_for(put: "/users/#{user.id}", response: from_api(user))
+  end
+
+  describe 'Sends an email on password update' do
+    subject { user.update(updates) }
+
+    context 'when password change notifications are enabled' do
+      before { user.class.send_password_change_notification = true }
+
+      context 'when the user is confirmed' do
+        let(:user) { build(:user, email: 'test@maestrano.com', password: 'oldpass', confirmed_at: nil) }
+        let(:updates) { {password: 'newpass', password_confirmation: 'newpass', confirmed_at: Time.current} }
+
+        it 'does not send an email' do
+          expect(user).not_to receive(:send_devise_notification)
+          subject
+        end
+      end
+
+      context 'when the password is changed' do
+        let(:updates) { {password: 'newpass', password_confirmation: 'newpass'} }
+
+        it 'sends an email' do
+          expect(user).to receive(:send_devise_notification).with(:password_change)
+          subject
+        end
+      end
+    end
+
+    context 'when password does not change notifications are disabled' do
+      before { user.class.send_password_change_notification = false }
+
+      context 'when the password is not updated' do
+        let(:updates) { {name: 'Bob'} }
+
+        it 'does not send an email' do
+          expect(user).not_to receive(:send_devise_notification)
+          subject
+        end
+      end
+
+      context 'when the password to change is invalid' do
+        let(:updates) { {password: '', password_confirmation: ''} }
+
+        it 'does not send an email' do
+          expect(user).not_to receive(:send_devise_notification)
+          subject
+        end
+      end
+
+      context 'when the password and its confirmation are different' do
+        let(:updates) { {password: 'password1', password_confirmation: 'another_password'} }
+
+        it 'does not send an email' do
+          expect(user).not_to receive(:send_devise_notification)
+          subject
+        end
+      end
+
+      context 'when the password is given without confirmation' do
+        let(:updates) { {password: 'new_password'} }
+
+        it 'does not send an email' do
+          expect(user).not_to receive(:send_devise_notification)
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/lib/mno_enterprise/impac_client_spec.rb

@@ -0,0 +1,31 @@
+require "rails_helper"
+
+describe MnoEnterprise::ImpacClient do
+  subject { MnoEnterprise::ImpacClient }
+
+  let(:host_path) { "http://localhost:4000" }
+  let(:params) { { sso_session: '1234' } }
+  let(:endpoint) { "/some/endpoint" }
+  let(:url) { "http://localhost:4000/some/endpoint?sso_session=1234" }
+
+  describe ".host" do
+    it { expect(subject.host).to eq(host_path) }
+  end
+
+  describe ".endpoint_url" do
+    it { expect(subject.endpoint_url(endpoint, params)).to eq(url) }
+    context "when the endpoint misses the first '/'" do
+      let(:endpoint) { "some/endpoint" }
+      it { expect(subject.endpoint_url(endpoint, params)).to eq(url) }
+    end
+  end
+
+  describe ".send_get" do
+    let(:opts) { {some: 'opts'} }
+
+    before { allow(subject).to receive(:get).with(url, opts).and_return(true) }
+
+    it { expect(subject.send_get(endpoint, params, opts)).to eq(true) }
+  end
+
+end

data/spec/mno_enterprise_spec.rb

@@ -51,28 +51,27 @@ describe MnoEnterprise do
   end
 
   context 'router' do
+    let(:id) { "cld-1d45e6" }
+    let(:root_path) { "#{MnoEnterprise.mno_api_host}#{MnoEnterprise.mno_api_root_path}" }
 
     describe 'launch_url' do
-      let(:id) { "cld-1d45e6" }
-      let(:url) { "#{MnoEnterprise.mno_api_host}#{MnoEnterprise.mno_api_root_path}/launch/#{id}" }
+
+      let(:url) { "#{root_path}/launch/#{id}" }
       it { expect(MnoEnterprise.router.launch_url(id)).to eq(url) }
     end
 
     describe 'authorize_oauth_url' do
-      let(:id) { "cld-1d45e6" }
-      let(:url) { "#{MnoEnterprise.mno_api_host}#{MnoEnterprise.mno_api_root_path}/oauth/#{id}/authorize" }
+      let(:url) { "#{root_path}/oauth/#{id}/authorize" }
       it { expect(MnoEnterprise.router.authorize_oauth_url(id)).to eq(url) }
     end
 
     describe 'disconnect_oauth_url' do
-      let(:id) { "cld-1d45e6" }
-      let(:url) { "#{MnoEnterprise.mno_api_host}#{MnoEnterprise.mno_api_root_path}/oauth/#{id}/disconnect" }
+      let(:url) { "#{root_path}/oauth/#{id}/disconnect" }
       it { expect(MnoEnterprise.router.disconnect_oauth_url(id)).to eq(url) }
     end
 
     describe 'sync_oauth_url' do
-      let(:id) { "cld-1d45e6" }
-      let(:url) { "#{MnoEnterprise.mno_api_host}#{MnoEnterprise.mno_api_root_path}/oauth/#{id}/sync" }
+      let(:url) { "#{root_path}/oauth/#{id}/sync" }
       it { expect(MnoEnterprise.router.sync_oauth_url(id)).to eq(url) }
     end
   end

data/spec/models/mno_enterprise/app_spec.rb

@@ -26,7 +26,7 @@ module MnoEnterprise
     end
 
     describe 'appinfo methods' do
-      %i(single_billing? coming_soon?).each do |method|
+      %i(single_billing? coming_soon? add_on?).each do |method|
         it { expect(described_class.new).to respond_to(method) }
       end
     end

data/spec/models/mno_enterprise/identity_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+module MnoEnterprise
+  RSpec.describe Identity, type: :model do
+    let(:auth) { OmniAuth::AuthHash.new(provider: 'test', uid: 'usr-123') }
+    let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid) }
+
+    describe '.find_for_oauth' do
+      subject { described_class.find_for_oauth(auth) }
+
+      context 'when the identity exist' do
+        before do
+          filter = {uid: auth.uid, provider: auth.provider}
+          api_stub_for(get: "/identities", params: {filter: filter}, response: from_api([identity]))
+          # We don't stub POST identities therefore testing there's no creation
+        end
+
+        it 'returns the existing entity' do
+          expect(subject).to eq(identity)
+        end
+      end
+
+      context 'when the identity does not exist' do
+        before do
+          filter = {uid: auth.uid, provider: auth.provider}
+          api_stub_for(get: "/identities", params: {filter: filter}, response: from_api([]))
+
+          # Test that it creates the entity? How can we add expect on post?
+          api_stub_for(post: "/identities", response: from_api(identity))
+        end
+
+        # find or create
+        it 'creates the identity and returns it' do
+          expect(subject).to eq(identity)
+        end
+      end
+    end
+  end
+end

data/spec/models/mno_enterprise/organization_spec.rb

@@ -1,7 +1,24 @@
 require 'rails_helper'
 
 module MnoEnterprise
-  RSpec.describe Organization, :type => :model do
-    pending "add some examples to (or delete) #{__FILE__}"
+  RSpec.describe Organization, type: :model do
+    describe '#payment_restriction' do
+      let(:organization) { FactoryGirl.build(:organization) }
+      subject { organization.payment_restriction }
+
+      context 'without metadata' do
+        it { is_expected.to be nil }
+      end
+
+      context 'without payment restriction' do
+        before { organization.meta_data = {} }
+        it { is_expected.to be nil }
+      end
+
+      context 'with payment restriction' do
+        before { organization.meta_data = {payment_restriction: ['visa']} }
+        it { is_expected.to eq(['visa']) }
+      end
+    end
   end
 end

data/spec/models/mno_enterprise/user_spec.rb

@@ -37,8 +37,246 @@ module MnoEnterprise
           load 'app/models/mno_enterprise/user.rb'
         end
       end
+    end
+
+    describe :intercom_user_hash do
+      let(:user) { MnoEnterprise::User.new(email: 'admin@example.com') }
+
+      context 'without Intercom' do
+        # default
+        it { expect(user).not_to respond_to(:intercom_user_hash) }
+      end
+
+      context 'with Intercom' do
+        before do
+          allow(MnoEnterprise).to receive(:intercom_enabled?).and_return(true)
+          allow(MnoEnterprise).to receive(:intercom_api_secret).and_return('mysecret')
+
+          # Reload User class to include IntercomUser concern
+          MnoEnterprise.send(:remove_const, :User)
+          load 'app/models/mno_enterprise/user.rb'
+        end
+
+        it 'returns the user intercom hash' do
+          expect(user.intercom_user_hash).not_to be_nil
+        end
 
+        after do
+          # Reset to default
+          MnoEnterprise.send(:remove_const, :User)
+          load 'app/models/mno_enterprise/user.rb'
+        end
+      end
     end
 
+    describe 'Omniauth' do
+      let(:firstname) { "Jack" }
+      let(:lastname) { "Beauregard" }
+      let(:provider) { 'someprovider' }
+      let(:auth) { OmniAuth::AuthHash.new(
+        {
+          provider: provider,
+          uid: '123545',
+          info: {
+            first_name: firstname,
+            last_name: lastname,
+            email: 'jack.beauregard@maestrano.com'
+          }
+        }
+      ) }
+
+
+      describe '.find_for_oauth' do
+        it { expect(described_class).to respond_to(:find_for_oauth) }
+
+        subject { described_class.find_for_oauth(auth) }
+
+        context 'without a signed in user' do
+
+          context 'with a matching identity' do
+            let(:user) { build(:user, email: auth.info.email) }
+            let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid, user: user.attributes) }
+
+            before { expect(Identity).to receive(:find_for_oauth) { identity } }
+
+            it 'returns the matching user' do
+              expect(subject).to eq(user)
+            end
+
+            it 'does not create a new user' do
+              expect(described_class).not_to receive(:create_from_omniauth)
+              subject
+            end
+          end
+
+          context 'with no matching identity' do
+            let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid) }
+            before { expect(Identity).to receive(:find_for_oauth) { identity } }
+
+            context 'when a user with a matching email exists' do
+              let(:user) { build(:user, email: auth.info.email) }
+              before do
+                api_stub_for(get: "/users", params: {filter: {email: auth.info.email}}, response: from_api([user]))
+                api_stub_for(post: "/identities", response: from_api(identity))
+              end
+
+              it 'associates the new identity with the user' do
+                subject
+                expect(identity.user_id).to eq(user.id)
+              end
+
+              it 'returns the matching user' do
+                expect(subject).to eq(user)
+              end
+
+              it 'does not create a new user' do
+                expect(described_class).not_to receive(:create_from_omniauth)
+                subject
+              end
+
+              context 'with Intuit provider' do
+                let(:provider) { 'intuit' }
+
+                context 'when email is authorised' do
+                  subject { described_class.find_for_oauth(auth, authorized_link_to_email: auth[:info][:email]) }
+                  it 'does not raise an error' do
+                    expect { subject }.not_to raise_error
+                  end
+                end
+
+                context 'when email is not authorised' do
+                  it 'raises an error' do
+                    expect { subject }.to raise_error(SecurityError, 'reconfirm credentials')
+                  end
+                end
+              end
+            end
+
+            context 'when no user with a matching email exists' do
+              let(:user) { described_class.new }
+              let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid) }
+
+              before do
+                api_stub_for(get: "/users", params: {filter: {email: auth.info.email}}, response: from_api(nil))
+                api_stub_for(post: "/identities", response: from_api(identity))
+              end
+
+              it 'creates and returns a new user' do
+                expect(described_class).to receive(:create_from_omniauth).with(auth, {}).and_return(user)
+                expect(subject).to eq(user)
+              end
+            end
+          end
+        end
+
+        context 'with a signed in user' do
+          let(:user) { FactoryGirl.build(:user) }
+          subject { described_class.find_for_oauth(auth, {}, user) }
+
+          context 'when the identity match the current user' do
+            let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid, user: user.attributes) }
+            before { expect(Identity).to receive(:find_for_oauth) { identity } }
+
+            it 'does not touch the identity' do
+              # no stub
+              subject
+            end
+
+            it 'returns the current user' do
+              expect(subject).to eq(user)
+            end
+
+            it 'does not create a new user' do
+              expect(described_class).not_to receive(:create_from_omniauth)
+              subject
+            end
+          end
+
+          context 'when the identity does not match the current user' do
+            let(:identity) { build(:identity, provider: auth.provider, uid: auth.uid) }
+            before { expect(Identity).to receive(:find_for_oauth) { identity } }
+
+            before do
+              api_stub_for(post: "/identities", response: from_api(identity))
+            end
+
+            it 're-assign the identity to the current user' do
+              subject
+              expect(identity.user_id).to eq(user.id)
+            end
+
+            it 'returns the current user' do
+              expect(subject).to eq(user)
+            end
+
+            it 'does not create a new user' do
+              expect(described_class).not_to receive(:create_from_omniauth)
+              subject
+            end
+          end
+        end
+      end
+
+      describe '.create_from_omniauth' do
+        let(:user) { build(:user) }
+
+        before do
+          allow(MnoEnterprise::User).to receive(:new) { user }
+          allow(user).to receive(:save) { user }
+        end
+
+        subject { described_class.create_from_omniauth(auth) }
+
+        it { expect(described_class).to respond_to(:create_from_omniauth) }
+
+        it 'creates a new user with the proper fields' do
+          expect(MnoEnterprise::User).to receive(:new).with(
+            hash_including(
+              name: auth.info.first_name,
+              surname: auth.info.last_name,
+              email: auth.info.email
+            )).and_return(user)
+          subject
+        end
+
+        it 'skips email confirmation' do
+          expect(user).to receive(:skip_confirmation!)
+          expect(subject).to be_confirmed
+        end
+
+        context 'with Intuit provider' do
+          let(:provider) { 'intuit' }
+
+          it 'does not skip email confirmation' do
+            expect(user).not_to receive(:skip_confirmation!)
+            subject
+          end
+        end
+
+        context 'with some params' do
+          let(:comp_name) { 'some company to be set' }
+          subject { described_class.create_from_omniauth(auth, company: comp_name) }
+
+          it 'creates a user with correct attributes' do
+            expect(subject.company).to eq(comp_name)
+          end
+        end
+
+        context 'when omniauth provides a user with no name' do
+          let(:firstname) { nil }
+          let(:lastname) { nil }
+
+          it "creates a user with name='first_part_of_email' and surname=''" do
+            expect(MnoEnterprise::User).to receive(:new).with(
+              hash_including(
+                name: 'jack.beauregard',
+                surname: '',
+                email: auth.info.email
+              )).and_return(user)
+            subject
+          end
+        end
+      end
+    end
   end
 end