mno-enterprise-core 2.0.0

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

@@ -0,0 +1,17 @@
+# Read about factories at https://github.com/thoughtbot/factory_girl
+
+FactoryGirl.define do
+  factory :mno_enterprise_team, :class => 'MnoEnterprise::Team' do
+    
+    factory :team, class: MnoEnterprise::Team do
+      sequence(:id) 
+      sequence(:name) { |n| "Team#{n}" }
+
+      created_at 3.days.ago 
+      updated_at 1.hour.ago
+      
+      # 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/tenant.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+
+  factory :tenant, class: MnoEnterprise::Tenant do
+    last_portfolio_amount Money.new(65644,'AUD')
+    last_customers_invoicing_amount Money.new(687994,'AUD')
+    last_customers_outstanding_amount Money.new(178986,'AUD')
+    last_commission_amount Money.new(412345,'AUD')
+
+    # Properly build the resource with Her
+    initialize_with { new(attributes).tap { |e| e.clear_attribute_changes! } }
+  end
+end

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

@@ -0,0 +1,29 @@
+# Read about factories at https://github.com/thoughtbot/factory_girl
+
+FactoryGirl.define do
+  factory :mno_enterprise_tenant_invoice, :class => 'TenantInvoice' do
+    
+    
+    factory :tenant_invoice, class: MnoEnterprise::TenantInvoice do
+      sequence(:id)
+      sequence(:slug) { |n| "201504-NU#{n}" }
+      organization_id 265
+      
+      started_at 28.days.ago
+      ended_at 3.days.ago
+      created_at 3.days.ago 
+      updated_at 1.hour.ago
+      paid_at nil
+
+      total_commission_amount Money.new(0,'AUD')
+      total_portfolio_amount Money.new(0,'AUD')
+      non_commissionable_amount Money.new(0,'AUD')
+      mno_commission_amount Money.new(0,'AUD')
+
+      # 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/users.rb

@@ -0,0 +1,48 @@
+# Read about factories at https://github.com/thoughtbot/factory_girl
+
+# This is an API resource factory generating a Hash to be used in API stubs
+# Use as such: build(:api_user)
+# See http://stackoverflow.com/questions/10032760/how-to-define-an-array-hash-in-factory-girl
+FactoryGirl.define do
+  
+  factory :user, class: MnoEnterprise::User do
+    sequence(:id)
+    sequence(:uid) { |n| "usr-fda9#{n}" }
+    name "John"
+    surname "Doe"
+    sequence(:email) { |n| "john.doe#{n}@maestrano.com" }
+    company "Doe Inc."
+    phone "449 789 456"
+    phone_country_code "AU"
+    geo_country_code "AU"
+    geo_state_code "NSW"
+    geo_city "Sydney"
+    created_at 2.days.ago
+    updated_at 2.days.ago
+    sso_session "1fdd5sf5a73D7sd1as2a4sd541"
+    admin_role false
+
+    confirmation_sent_at 2.days.ago
+    confirmation_token "wky763pGjtzWR7dP44PD"
+    confirmed_at 1.days.ago
+    
+    trait :unconfirmed do
+      confirmed_at nil
+    end
+
+    trait :admin do
+      admin_role true
+    end
+
+    trait :with_deletion_request do
+      deletion_request { build(:deletion_request).attributes }
+    end
+    
+    trait :with_organizations do
+      organizations { [build(:organization).attributes] }
+    end
+    
+    # Properly build the resource with Her
+    initialize_with { new(attributes).tap { |e| e.clear_attribute_changes! } }
+  end
+end

data/lib/mno_enterprise/testing_support/jpi_v1_test_helper.rb

@@ -0,0 +1,49 @@
+module MnoEnterprise::TestingSupport::JpiV1TestHelper
+
+  # Expect 'user' to be assigned
+  shared_examples "jpi v1 protected action" do
+    context "with guest user" do
+      it "prevents access" do
+        sign_out user
+        expect(subject).to_not be_successful
+        expect(subject.code).to eq('401')
+      end
+    end
+
+    context 'with signed in user' do
+      it "authorizes access" do
+        sign_in user
+        expect(subject).to be_successful
+      end
+    end
+  end
+
+  # Expect 'user' to be assigned
+  # Expect 'ability' to be assigned
+  shared_examples "jpi v1 authorizable action" do
+    context "with guest user" do
+      it "prevents access" do
+        sign_out user
+        expect(subject).to_not be_successful
+        expect(subject.code).to eq('401')
+      end
+    end
+
+    context 'with unauthorized signed in user' do
+      it "prevents access" do
+        sign_in user
+        allow(ability).to receive(:can?).with(any_args).and_return(false)
+        expect(subject).to_not be_successful
+      end
+    end
+
+    context 'with authorized signed in user' do
+      it "authorizes access" do
+        sign_in user
+        allow(ability).to receive(:can?).with(any_args).and_return(true)
+        expect(subject).to be_successful
+      end
+    end
+  end
+
+end

data/lib/mno_enterprise/testing_support/mno_enterprise_api_test_helper.rb

@@ -0,0 +1,167 @@
+module MnoEnterpriseApiTestHelper
+  
+  # Take a resource and transform it into a Hash describing
+  # the resource as if it had been returned by the MnoEnterprise
+  # API server
+  def from_api(res)
+    { data: serialize_type(res), metadata: {pagination: {count: entity_count(res)}} }
+  end
+  
+  def serialize_type(res)
+    case
+    when res.kind_of?(Array)
+      return res.map { |e| serialize_type(e) }
+    when res.kind_of?(MnoEnterprise::BaseResource)
+      hash = res.attributes.dup
+      hash.each do |k,v|
+        hash[k] = serialize_type(v)
+      end
+      return hash
+    when res.kind_of?(Hash)
+      hash = res.dup
+      hash.each do |k,v|
+        hash[k] = serialize_type(v)
+      end
+      return hash
+    when res.kind_of?(Money)
+      return { cents: res.cents, currency: res.currency_as_string }
+    when res.respond_to?(:iso8601)
+      return res.iso8601
+    else
+      return res
+    end
+  end
+
+  def entity_count(res)
+    case
+    when res.kind_of?(Array)
+      return res.count
+    when res.kind_of?(Hash)
+      return res.count
+    else
+      return 1
+    end
+  end
+  
+  # Reset all API stubs.
+  # Called before each test (see spec_helper)
+  def api_stub_reset
+    @_api_stub = nil
+    @_stub_list = {}
+    api_stub_configure(Her::API.new)
+  end
+  
+  # Example usage:
+  # 
+  # Without opts, it yields a faraday stub object which you can configure
+  # manually:
+  #
+  # You can also pass the response stub via opts
+  # api_stub_for(User, 
+  #   path: '/users/popular', 
+  #   response: [{ id: 1, name: "Tobias Fünke" }, { id: 2, name: "Lindsay Fünke" }]
+  # )
+  #
+  # You can also specify the response code:
+  # api_stub_for(User, 
+  #   path: '/users/popular',
+  #   code: 200,
+  #   response: [{ id: 1, name: "Tobias Fünke" }, { id: 2, name: "Lindsay Fünke" }]
+  # )
+  def api_stub_for(klass, opts = {})
+    real_opts = klass
+    if klass.is_a?(Class)
+      warn("DEPRECATION WARNING: api_stub_for(MyClass,{ some: 'opts'}) is deprecated. Please use api_stub_for({ some: 'opts' }) from now on")
+      real_opts = opts
+    end
+    
+    set_api_stub
+    api_stub_add(real_opts)
+    api_stub_configure(@_api_stub)
+  end
+  
+  private
+    # Set a stub api on the provider class
+    def set_api_stub
+      return @_api_stub if @_api_stub
+      @_api_stub = Her::API.new
+      allow(MnoEnterprise::BaseResource).to receive(:her_api).and_return(@_api_stub = Her::API.new)
+      @_api_stub
+    end
+  
+    # Add a stub to the api
+    # E.g.:
+    # { 
+    #   path: '/users/popular',
+    #   code: 200,
+    #   response: [{ id: 1, name: "Tobias Fünke" }, { id: 2, name: "Lindsay Fünke" }]
+    # }
+    def api_stub_add(orig_opts)
+      @_stub_list ||= {}
+      opts = orig_opts.dup
+      
+      # Expand options so that: { put: '/path' } becomes { path: '/path', method: :put }
+      unless opts[:method] && opts[:path]
+        [:get,:put,:post,:delete].each do |verb|
+          if path = opts.delete(verb)
+            opts[:path] = path
+            opts[:method] = verb
+          end
+        end
+      end
+      
+      key = opts.to_param
+      @_stub_list[key] = opts
+    end
+  
+    # Configure the api and apply a list of stubs
+    def api_stub_configure(api)
+      # This block should match the her.rb initializer
+      api.setup MnoEnterprise.send(:api_options).merge(url: "http://localhost:65000") do |c|
+        # Request
+        c.use Faraday::Request::BasicAuthentication, MnoEnterprise.tenant_id, MnoEnterprise.tenant_key
+        c.use Faraday::Request::UrlEncoded
+
+        # Response
+        c.use Her::Middleware::MnoeApiV1ParseJson
+      
+        # Add stubs on the test adapter
+        c.use MnoeFaradayTestAdapter do |receiver|
+          @_stub_list.each do |key,stub|
+            params = stub[:params] && stub[:params].any? ? "?#{stub[:params].to_param}" : ""
+            path = "#{stub[:path]}#{params}"
+            
+            receiver.send(stub[:method] || :get,path) { |env|
+              body = Rack::Utils.parse_nested_query(env.body)
+              
+              # respond_with takes a model in argument and automatically responds with
+              # a json representation of the model
+              # If the action is an update, it attempts to update the model
+              if model = stub[:respond_with]
+                model.assign_attributes(body['data']) if stub[:method] == :put && model.respond_to?(:assign_attributes) && body['data']
+                resp = from_api(model)
+              else
+                if stub[:response].is_a?(Proc)
+                  args = stub[:response].arity > 0 ? [body] : []
+                  resp = stub[:response].call(*args)
+                else
+                  resp = stub[:response] || {}
+                end
+              end
+              
+              # Response code
+              if stub[:code].is_a?(Proc)
+                args = stub[:code].arity > 0 ? [body] : []
+                resp_code = stub[:code].call(*args)
+              else
+                resp_code = stub[:code] || 200
+              end
+                 
+              
+              [resp_code, {}, resp.to_json] 
+            }
+          end
+        end
+      end
+    end
+end

data/lib/mno_enterprise/testing_support/mnoe_faraday_test_adapter.rb

@@ -0,0 +1,173 @@
+# Adapter and modified from: https://github.com/lostisland/faraday/blob/master/lib/faraday/adapter/test.rb
+#
+#
+#
+# test = Faraday::Connection.new do
+#   use MnoeFaradayTestAdapter do |stub|
+#     stub.get '/nigiri/sake.json' do
+#       [200, {}, 'hi world']
+#     end
+#   end
+# end
+#
+# resp = test.get '/nigiri/sake.json'
+# resp.body # => 'hi world'
+#
+class MnoeFaradayTestAdapter < Faraday::Adapter
+  attr_accessor :stubs
+
+  class Stubs
+    class NotFound < StandardError
+    end
+
+    def initialize
+      # {:get => [Stub, Stub]}
+      @stack, @consumed = {}, {}
+      yield(self) if block_given?
+    end
+
+    def empty?
+      @stack.empty?
+    end
+
+    def match(request_method, path, headers, body)
+      return false if !@stack.key?(request_method)
+      stack = @stack[request_method]
+      consumed = (@consumed[request_method] ||= [])
+
+      if stub = matches?(stack, path, headers, body)
+        consumed << stack.delete(stub)
+        stub
+      else
+        matches?(consumed, path, headers, body)
+      end
+    end
+
+    def get(path, headers = {}, &block)
+      new_stub(:get, path, headers, &block)
+    end
+
+    def head(path, headers = {}, &block)
+      new_stub(:head, path, headers, &block)
+    end
+
+    def post(path, body=nil, headers = {}, &block)
+      new_stub(:post, path, headers, body, &block)
+    end
+
+    def put(path, body=nil, headers = {}, &block)
+      new_stub(:put, path, headers, body, &block)
+    end
+
+    def patch(path, body=nil, headers = {}, &block)
+      new_stub(:patch, path, headers, body, &block)
+    end
+
+    def delete(path, headers = {}, &block)
+      new_stub(:delete, path, headers, &block)
+    end
+
+    def options(path, headers = {}, &block)
+      new_stub(:options, path, headers, &block)
+    end
+
+    # Raises an error if any of the stubbed calls have not been made.
+    def verify_stubbed_calls
+      failed_stubs = []
+      @stack.each do |method, stubs|
+        unless stubs.size == 0
+          failed_stubs.concat(stubs.map {|stub|
+            "Expected #{method} #{stub}."
+          })
+        end
+      end
+      raise failed_stubs.join(" ") unless failed_stubs.size == 0
+    end
+
+    protected
+
+    def new_stub(request_method, path, headers = {}, body=nil, &block)
+      normalized_path = Faraday::Utils.normalize_path(path)
+      (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
+    end
+
+    def matches?(stack, path, headers, body)
+      stack.detect { |stub| stub.matches?(path, headers, body) }
+    end
+  end
+
+  class Stub < Struct.new(:path, :params, :headers, :body, :block)
+    def initialize(full, headers, body, block)
+      path, query = full.split('?')
+      params = query ?
+        Faraday::Utils.parse_nested_query(query) :
+        {}
+      super(path, params, headers, body, block)
+    end
+
+    def matches?(request_uri, request_headers, request_body)
+      request_path, request_query = request_uri.split('?')
+      request_params = request_query ?
+        Faraday::Utils.parse_nested_query(request_query) :
+        {}
+      request_path == path &&
+        params_match?(request_params) &&
+        (body.to_s.size.zero? || request_body == body) &&
+        headers_match?(request_headers)
+    end
+
+    def params_match?(request_params)
+      params_deep_equal?(params,request_params)
+      # params.keys.all? do |key|
+      #   request_params[key] == params[key]
+      # end
+    end
+    
+    def params_deep_equal?(src,dst)
+      src.keys.all? do |key|
+        if src[key] && dst[key] && src[key].is_a?(Hash) && dst[key].is_a?(Hash)
+          params_deep_equal?(src[key],dst[key])
+        else
+          (src[key] == '**' && dst[key]) || src[key] == dst[key]
+        end
+      end
+    end
+
+    def headers_match?(request_headers)
+      headers.keys.all? do |key|
+        request_headers[key] == headers[key]
+      end
+    end
+
+    def to_s
+      "#{path} #{body}"
+    end
+  end
+
+  def initialize(app, stubs=nil, &block)
+    super(app)
+    @stubs = stubs || Stubs.new
+    configure(&block) if block
+  end
+
+  def configure
+    yield(stubs)
+  end
+
+  def call(env)
+    super
+    normalized_path = Faraday::Utils.normalize_path(env[:url])
+    params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
+
+    if stub = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+      env[:params] = (query = env[:url].query) ?
+        params_encoder.decode(query)  :
+        {}
+      status, headers, body = stub.block.call(env)
+      save_response(env, status, body, headers)
+    else
+      raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
+    end
+    @app.call(env)
+  end
+end