praxis 0.22.pre.2 → 2.0.pre.1

data/lib/praxis/plugins/praxis_mapper_plugin.rb

@@ -1,246 +0,0 @@
-require 'praxis-mapper'
-require 'singleton'
-
-require 'terminal-table'
-
-# Plugin for applications which use the 'praxis-mapper' gem.
-#
-# This plugin provides the following features:
-#   1. Sets up the PraxisMapper::IdentityMap for your application and assigns
-#      it to the controller's request.identity_map for access from your
-#      application.
-#   2. Connects to your database and dumps a log of database interaction stats
-#      (if enabled via the :log_stats option).
-#
-# This plugin accepts one of the following options:
-#   1. config_file: A String indicating the path where this plugin's config
-#      file exists.
-#   2. config_data: A Hash of data that is merged into the YAML hash loaded
-#      from config_file.
-#
-# The config_data Hash contains the following keys:
-#   1. repositories: A Hash containing the configs for the database repositories
-#      queried through praxis-mapper. This parameter is a Hash where a key is
-#      the identifier for a repository and the value is the options one
-#      would give to the 'sequel' gem. For example:
-#           repositories: {
-#             default: {
-#               host: 127.0.0.1,
-#               username: root,
-#               password: nil,
-#               database: myapp_dev,
-#               adapter: mysql2
-#             }
-#           }
-#   2. log_stats: A String indicating what kind of DB stats you would like
-#      output into the Praxis::Application.current_instance.logger app log. Possible
-#      values are: "detailed", "short", and "skip" (i.e. do not print the stats
-#      at all).
-#   3. stats_log_level: the logging level with which the statistics should be logged.
-#
-# See http://praxis-framework.io/reference/plugins/ for further details on how
-# to use a plugin and pass it options.
-#
-module Praxis
-  module Plugins
-    module PraxisMapperPlugin
-      include Praxis::PluginConcern
-
-      class RepositoryConfig < Attributor::Hash
-        self.key_type = String
-
-        keys allow_extra: true do
-          key 'type', String, default: 'sequel'
-          extra 'connection_settings'
-        end
-
-      end
-
-
-      class Plugin < Praxis::Plugin
-        include Singleton
-
-        def initialize
-          @options = {
-            config_file: 'config/praxis_mapper.yml',
-            config_data: {
-              repositories: {}
-            }
-          }
-        end
-
-        def config_key
-          :praxis_mapper
-        end
-
-        def prepare_config!(node)
-          node.attributes do
-            attribute :log_stats, String, values: ['detailed', 'short', 'skip'], default: 'detailed'
-            attribute :stats_log_level, Symbol, values: [:fatal,:error,:warn,:info,:debug], default: :info
-            attribute :repositories, Attributor::Hash.of(key: String, value: RepositoryConfig)
-          end
-        end
-
-        # Make our own custom load_config! method
-        def load_config!
-          config_file_path = application.root + options[:config_file]
-          result = config_file_path.exist? ? YAML.load_file(config_file_path) : {}
-          result.merge(@options[:config_data])
-        end
-
-        def setup!
-          self.config.repositories.each do |repository_name, repository_config|
-            type = repository_config['type']
-            connection_settings = repository_config['connection_settings']
-
-            case type
-            when 'sequel'
-              self.setup_sequel_repository(repository_name, connection_settings)
-            else
-              raise "unsupported repository type: #{type}"
-            end
-          end
-
-          log_stats = PraxisMapperPlugin::Plugin.instance.config.log_stats
-          unless log_stats == 'skip'
-            Praxis::Notifications.subscribe 'praxis.request.all' do |name, *junk, payload|
-              if (payload[:request].identity_map?)
-                identity_map = payload[:request].identity_map
-                PraxisMapperPlugin::Statistics.log(payload[:request], identity_map, log_stats)
-              end
-            end
-          end
-        end
-
-        def setup_sequel_repository(name, settings)
-          db = Sequel.connect(settings.dump.symbolize_keys)
-
-          Praxis::Mapper::ConnectionManager.setup do
-            repository(name.to_sym) { db }
-          end
-        end
-      end
-
-      module Request
-        def identity_map
-          @identity_map ||= Praxis::Mapper::IdentityMap.new
-        end
-
-        def identity_map=(map)
-          @identity_map = map
-        end
-
-        def identity_map?
-          !@identity_map.nil?
-        end
-
-        def silence_mapper_stats
-          @silence_mapper_stats
-        end
-
-        def silence_mapper_stats=(value)
-          @silence_mapper_stats = value
-        end
-
-      end
-
-      module Controller
-        extend ActiveSupport::Concern
-
-        included do
-          # Ensure we call #release on any identity map
-          # that may be set by the controller after the action
-          # completes.
-          around :action do |controller, callee|
-            begin
-              callee.call
-            ensure
-              if controller.request.identity_map?
-                controller.request.identity_map.release
-              end
-            end
-          end
-        end
-
-        def identity_map
-          request.identity_map
-        end
-
-      end
-
-      module Statistics
-
-        def self.log(request, identity_map, log_stats)
-          return if identity_map.nil?
-          return if request.silence_mapper_stats == true
-          if identity_map.queries.empty?
-            self.to_logger "No database interactions observed."
-            return
-          end
-
-
-          case log_stats
-          when 'detailed'
-            self.detailed(identity_map)
-          when 'short'
-            self.short(identity_map)
-          when 'skip'
-            # Shouldn't receive this. But anyway...no-op.
-          end
-        end
-
-        def self.detailed(identity_map)
-          stats_by_model = identity_map.query_statistics.sum_totals_by_model
-          stats_total = identity_map.query_statistics.sum_totals
-          fields = [ :query_count, :records_loaded, :datastore_interactions, :datastore_interaction_time]
-          rows = []
-
-          total_models_loaded = 0
-          # stats per model
-          stats_by_model.each do |model, totals|
-            total_values = totals.values_at(*fields)
-            self.round_fields_at( total_values , [fields.index(:datastore_interaction_time)])
-            row = [ model ] + total_values
-            models_loaded = identity_map.all(model).size
-            total_models_loaded += models_loaded
-            row << models_loaded
-            rows << row
-          end
-
-          rows << :separator
-
-          # totals for all models
-          stats_total_values = stats_total.values_at(*fields)
-          self.round_fields_at(stats_total_values , [fields.index(:datastore_interaction_time)])
-          rows << [ "All Models" ] + stats_total_values + [total_models_loaded]
-
-          table = Terminal::Table.new \
-            :rows => rows,
-            :title => "Praxis::Mapper Statistics",
-            :headings => [ "Model", "# Queries", "Records Loaded", "Interactions", "Time(sec)", "Models Loaded" ]
-
-          table.align_column(1, :right)
-          table.align_column(2, :right)
-          table.align_column(3, :right)
-          table.align_column(4, :right)
-          table.align_column(5, :right)
-          self.to_logger "\n#{table.to_s}"
-        end
-
-        def self.round_fields_at(values, indices)
-          indices.each do |idx|
-            values[idx] = "%.3f" % values[idx]
-          end
-        end
-
-        def self.short(identity_map)
-          self.to_logger identity_map.query_statistics.sum_totals.to_s
-        end
-
-        def self.to_logger(message)
-            Praxis::Application.current_instance.logger.__send__(Plugin.instance.config.stats_log_level, "Praxis::Mapper Statistics: #{message}")
-        end
-      end
-    end
-  end
-end

data/spec/praxis/media_type_collection_spec.rb

@@ -1,157 +0,0 @@
-require "spec_helper"
-
-describe Praxis::MediaTypeCollection do
-
-  subject!(:media_type_collection) do
-    silence_warnings do
-      klass = Class.new(Praxis::MediaTypeCollection) do
-        member_type VolumeSnapshot
-        description 'A container for a collection of Volumes'
-        display_name 'Volumes Collection'
-
-        attributes do
-          attribute :name, String, regexp: /snapshots-(\w+)/
-          attribute :size, Integer
-          attribute :href, String
-        end
-
-        view :link do
-          attribute :name
-          attribute :size
-          attribute :href
-        end
-
-        member_view :default, using: :default
-      end
-
-      klass.finalize!
-      klass
-    end
-  end
-
-  context '.member_type' do
-    its(:member_type){ should be(VolumeSnapshot) }
-    its(:member_attribute){ should be_kind_of(Attributor::Attribute) }
-    its('member_attribute.type'){ should be(VolumeSnapshot) }
-  end
-
-  context '.load' do
-    context 'with a hash' do
-      let(:snapshots_data) { {name: 'snapshots',   href: '/bob/snapshots' } }
-      subject(:snapshots) { media_type_collection.load(snapshots_data) }
-
-       its(:name) { should eq(snapshots_data[:name]) }
-       its(:href) { should eq(snapshots_data[:href]) }
-
-       it 'has no members set' do
-         expect(snapshots.to_a).to eq([])
-       end
-     end
-
-
-    context 'loading an array' do
-      let(:snapshots_data) do
-        [{id: 1, name: 'snapshot-1'},
-         {id: 2, name: 'snapshot-2'}]
-      end
-
-      let(:snapshots) { media_type_collection.load(snapshots_data) }
-      subject(:members) { snapshots.to_a }
-
-      it 'sets the collection members' do
-        expect(members).to have(2).items
-
-        expect(members[0].id).to eq(1)
-        expect(members[0].name).to eq('snapshot-1')
-        expect(members[1].id).to eq(2)
-        expect(members[1].name).to eq('snapshot-2')
-      end
-
-      it 'has no attributes set' do
-        expect(snapshots.name).to be(nil)
-        expect(snapshots.size).to be(nil)
-        expect(snapshots.href).to be(nil)
-      end
-
-    end
-  end
-
-  context '#render' do
-    context 'for standard views' do
-      let(:snapshots_data) { {name: 'snapshots',   href: '/bob/snapshots' } }
-      let(:snapshots) { media_type_collection.load(snapshots_data) }
-      subject(:output) { snapshots.render(view: :link) }
-
-      its([:name]) { should eq(snapshots.name)}
-      its([:size]) { should eq(snapshots.size)}
-      its([:href]) { should eq(snapshots.href)}
-    end
-
-    context 'for members' do
-      let(:snapshots_data) do
-        [{id: 1, name: 'snapshot-1'},
-         {id: 2, name: 'snapshot-2'}]
-      end
-
-      let(:snapshots) { media_type_collection.load(snapshots_data) }
-
-      subject(:output) { media_type_collection.dump(snapshots, view: :default) }
-
-      it { should eq(snapshots.collect(&:render)) }
-    end
-
-  end
-
-  context '#validate' do
-
-
-    context 'with a hash' do
-      let(:snapshots_data) { {name: 'snapshots-1',   href: '/bob/snapshots' } }
-      subject(:snapshots) { media_type_collection.load(snapshots_data) }
-
-
-      it 'validates' do
-        expect(snapshots.validate).to be_empty
-      end
-
-      context 'with invalid attributes' do
-        let(:snapshots_data) { {name: 'notsnapshots',   href: '/bob/snapshots' } }
-        it 'returns the error' do
-          expect(snapshots.validate).to have(1).item
-          expect(snapshots.validate[0]).to match(/value \(notsnapshots\) does not match regexp/)
-        end
-      end
-    end
-
-    context 'for an array' do
-      let(:snapshots_data) do
-        [{id: 1, name: 'snapshot-1'},
-         {id: 2, name: 'snapshot-2'}]
-      end
-
-      subject(:snapshots) { media_type_collection.load(snapshots_data) }
-
-      it 'validates' do
-        expect(snapshots.validate).to be_empty
-      end
-
-      context 'with invalid members' do
-        let(:snapshots_data) do
-          [{id: 1, name: 'invalid-1'},
-           {id: 2, name: 'snapshot-2'}]
-        end
-
-        it 'returns the error' do
-          expect(snapshots.validate).to have(1).item
-          expect(snapshots.validate[0]).to match(/value \(invalid-1\) does not match regexp/)
-        end
-      end
-    end
-  end
-
-  context '#describe' do
-    subject(:described) { media_type_collection.describe }
-    its([:description]){ should be(media_type_collection.description)}
-    its([:display_name]){ should be(media_type_collection.display_name)}
-  end
-end

data/spec/praxis/plugins/praxis_mapper_plugin_spec.rb

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-describe Praxis::Plugins::PraxisMapperPlugin do
-
-  subject(:plugin) { Praxis::Plugins::PraxisMapperPlugin::Plugin.instance }
-  let(:config) { plugin.config }
-  context 'Plugin' do
-    context 'configuration' do
-      subject { config }
-      its(:log_stats) { should eq 'detailed' }
-      its(:stats_log_level) { should eq :info }
-      its(:repositories) { should have_key("default") }
-
-      context 'default repository' do
-        subject(:default) { config.repositories['default'] }
-        its(['type']) { should eq 'sequel' }
-        it 'has the right connection settings' do
-          if RUBY_PLATFORM !~ /java/
-            expect(subject['connection_settings'].dump).to eq( 'adapter' => 'sqlite','database' => ':memory:' )
-          else
-            expect(subject['connection_settings'].dump).to eq( 'adapter' => 'jdbc', 'uri' => 'jdbc:sqlite::memory:' )
-          end
-
-
-        end
-      end
-
-    end
-  end
-
-  context 'Request' do
-
-    it 'should have identity_map accessors' do
-      expect(Praxis::Plugins::PraxisMapperPlugin::Request.instance_methods).to include(:identity_map,:identity_map=)
-    end
-
-    it 'should have silence_mapper_stats accessors' do
-      expect(Praxis::Plugins::PraxisMapperPlugin::Request.instance_methods)
-            .to include(:silence_mapper_stats,:silence_mapper_stats=)
-    end
-  end
-  context 'functional test' do
-
-    def app
-      Praxis::Application.instance
-    end
-
-    let(:session) { double("session", valid?: true)}
-
-    around(:each) do |example|
-      orig_level = Praxis::Application.instance.logger.level
-      Praxis::Application.instance.logger.level = 2
-      example.run
-      Praxis::Application.instance.logger.level = orig_level
-    end
-
-    context 'with no identity_map set in the request' do
-      it 'does not log stats' do
-        expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:log)
-        the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
-        get '/api/clouds/1/instances/2?api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
-
-        expect(last_response.status).to eq(200)
-      end
-    end
-    context 'with an identity_map set in the request' do
-      it 'logs stats' do
-        expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:log).
-          with(kind_of(Praxis::Request),kind_of(Praxis::Mapper::IdentityMap), 'detailed').
-          and_call_original
-        the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
-        get '/api/clouds/1/instances/2?create_identity_map=true&api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
-
-        expect(last_response.status).to eq(200)
-      end
-    end
-
-  end
-
-  context 'Statistics' do
-    context '.log' do
-      let(:queries){ { some: :queries } }
-      let(:identity_map) { double('identity_map', queries: queries) }
-      let(:log_stats){ 'detailed' }
-      let(:request){ double('request', silence_mapper_stats: false ) }
-
-      after do
-        Praxis::Plugins::PraxisMapperPlugin::Statistics.log(request, identity_map, log_stats)
-      end
-
-      context 'when the request silences mapper stats' do
-        let(:request){ double('request', silence_mapper_stats: true ) }
-        it 'should not log anything' do
-          expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
-        end
-      end
-
-      context 'without the request silencing mapper stats' do
-        context 'when log_stats = detailed' do
-          it 'should call the detailed method' do
-             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:detailed).with(identity_map)
-           end
-        end
-
-        context 'when log_stats = short' do
-          let(:log_stats){ 'short' }
-          it 'should call the short method' do
-             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:short).with(identity_map)
-           end
-        end
-
-        context 'when log_stats = skip' do
-          let(:log_stats){ 'skip' }
-
-          it 'should not log anything' do
-            expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
-          end
-        end
-
-        context 'when there is no identity map' do
-          let(:identity_map) { nil }
-          it 'should not log anything' do
-            expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
-          end
-        end
-
-        context 'when no queries are logged in the identity map' do
-          let(:queries){ {} }
-          it 'should log a special message' do
-            expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:to_logger)
-                                                                   .with("No database interactions observed.")
-          end
-        end
-
-      end
-    end
-
-    it 'has specs for testing the detailed log output'
-    it 'has specs for testing the short log output'
-  end
-
-end