shamu 0.0.1 → 0.0.2

data/spec/lib/shamu/entities/list_scope/dates_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::ListScope::Dates do
+  let( :klass ) do
+    Class.new( Shamu::Entities::ListScope ) do
+      include Shamu::Entities::ListScope::Dates
+    end
+  end
+
+  it "has a :since attribute" do
+    expect( klass.attributes ).to have_key :since
+  end
+
+  it "has an :until attribute" do
+    expect( klass.attributes ).to have_key :until
+  end
+
+  it "coerces with #to_time if available" do
+    expect( Time ).to receive( :instance_method ).and_return( true )
+    value = double
+    expect( value ).to receive( :to_time )
+
+    klass.new( since: value )
+  end
+
+  it "includes paging values in to_param" do
+    time = Time.now
+    expect( klass.new( since: time, until: time ).params ).to eq since: time, until: time
+  end
+
+  it "should not be dated when using defaults" do
+    scope = klass.new
+    expect( scope.dated? ).to be_falsy
+  end
+
+  it "should not be dated when since is provided" do
+    scope = klass.new since: Time.now
+    expect( scope.dated? ).to be_truthy
+  end
+
+  it "should not be dated when until is provided" do
+    scope = klass.new until: Time.now
+    expect( scope.dated? ).to be_truthy
+  end
+
+end

data/spec/lib/shamu/entities/list_scope/paging_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::ListScope::Paging do
+  let( :klass ) do
+    Class.new( Shamu::Entities::ListScope ) do
+      include Shamu::Entities::ListScope::Paging
+    end
+  end
+
+  it "has a :page attribute" do
+    expect( klass.attributes ).to have_key :page
+  end
+
+  it "has a :per_page attribute" do
+    expect( klass.attributes ).to have_key :per_page
+  end
+
+  it "has a :default_per_page" do
+    expect( klass.attributes ).to have_key :default_per_page
+  end
+
+  it "uses default_per_page if not per_page set" do
+    expect( klass.new.per_page ).to eq 25
+  end
+
+  it "includes paging values in to_param" do
+    expect( klass.new.params ).to eq page: nil, per_page: 25
+  end
+
+  it "should not be paged if using defaults" do
+    scope = klass.new
+    expect( scope.paged? ).to be_falsy
+  end
+
+  it "should be paged when attribute specified" do
+    scope = klass.new page: 1
+    expect( scope.paged? ).to be_truthy
+  end
+
+end

data/spec/lib/shamu/entities/list_scope/scoped_paging_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::ListScope::Paging do
+  let( :klass ) do
+    Class.new( Shamu::Entities::ListScope ) do
+      include Shamu::Entities::ListScope::ScopedPaging
+    end
+  end
+
+  it "has a :page attribute" do
+    expect( klass.attributes ).to have_key :page
+  end
+
+  it "has a :page.number attribute" do
+    expect( klass.new.page.class.attributes ).to have_key :number
+  end
+
+  it "has a :page.size attribute" do
+    expect( klass.new.page.class.attributes ).to have_key :size
+  end
+
+  it "has a :page.default_size attribute" do
+    expect( klass.new.page.class.attributes ).to have_key :default_size
+  end
+
+  it "includes paging values in to_param" do
+    expect( klass.new.params ).to eq page: { number: nil, size: 25 }
+  end
+
+  it "should be paged when attribute specified" do
+    scope = klass.new page: { number: 1 }
+    expect( scope.scoped_page? ).to be_truthy
+  end
+
+  it "should not be paged if using defaults" do
+    scope = klass.new
+    expect( scope.scoped_page? ).to be_falsy
+  end
+end

data/spec/lib/shamu/entities/list_scope/sorting_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::ListScope::Paging do
+  let( :klass ) do
+    Class.new( Shamu::Entities::ListScope ) do
+      include Shamu::Entities::ListScope::Sorting
+    end
+  end
+
+  it "parses single values" do
+    scope = klass.new( sort_by: :first_name )
+    expect( scope.sort_by ).to eq first_name: :asc
+  end
+
+  it "parses array of values" do
+    scope = klass.new( sort_by: [ :first_name, :last_name ] )
+    expect( scope.sort_by ).to eq first_name: :asc, last_name: :asc
+  end
+
+  it "parses array of args to fluid_assignment" do
+    scope = klass.new
+    scope.sort_by :first_name, :last_name
+    expect( scope.sort_by ).to eq first_name: :asc, last_name: :asc
+  end
+
+  it "parses array via assignment" do
+    scope = klass.new
+    scope.sort_by = [ :first_name, :last_name ]
+    expect( scope.sort_by ).to eq first_name: :asc, last_name: :asc
+  end
+
+  it "parses hash" do
+    scope = klass.new sort_by: { first_name: :desc }
+    expect( scope.sort_by ).to eq first_name: :desc
+  end
+
+  it "parses array with hash" do
+    scope = klass.new sort_by: [{ last_name: :desc }]
+    expect( scope.sort_by ).to eq last_name: :desc
+  end
+
+  it "parses hash with array" do
+    scope = klass.new sort_by: { campaign: [ :created_at ] }
+    expect( scope.sort_by ).to eq campaign: { created_at: :asc }
+  end
+
+  it "includes sorting values in to_param" do
+    expect( klass.new( sort_by: :name ).params ).to eq sort_by: { name: :asc }
+  end
+
+  it "is not sorted with defaults" do
+    expect( klass.new.sorted? ).to be_falsy
+  end
+
+  it "is sorted when asked" do
+    expect( klass.new( sort_by: :name ).sorted? ).to be_truthy
+  end
+end

data/spec/lib/shamu/entities/list_scope_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::ListScope do
+
+  let( :klass ) do
+    Class.new( Shamu::Entities::ListScope ) do
+      def self.validates( * ); end
+
+      attribute :name, presence: true
+    end
+  end
+
+  describe ".coerce" do
+    it "coerces an instance of the scope to self" do
+      scope = klass.new
+      expect( klass.coerce( scope ) ).to be scope
+    end
+
+    it "coerces a hash" do
+      expect( klass.coerce( {} ) ).to be_a klass
+    end
+
+    it "coerces a nil" do
+      expect( klass.coerce( nil ) ).to be_a klass
+    end
+
+    it "raises ArgumentError on other values" do
+      expect do
+        klass.coerce( "" )
+      end.to raise_error ArgumentError
+    end
+  end
+
+  describe ".coerce!" do
+    it "raises ArgumentError if the scope has invalid params" do
+      scope = klass.new( name: nil )
+      expect( scope ).to receive( :valid? ).and_return false
+
+      expect do
+        klass.coerce!( scope )
+      end.to raise_error ArgumentError
+    end
+
+    it "returns the scope if the params are valid" do
+      scope = klass.new( name: nil )
+      expect( scope ).to receive( :valid? ).and_return true
+
+      expect do
+        klass.coerce!( scope )
+      end.not_to raise_error
+    end
+  end
+
+  describe "#except" do
+    it "excludes the requested params" do
+      instance = klass.new( name: "Orca" )
+      expect( instance.except( :name ).name ).to be_nil
+    end
+
+    it "returns an instance of the same class" do
+      instance = klass.new( name: "Killer" )
+      expect( instance.except ).to be_a klass
+    end
+  end
+
+  describe "#params" do
+    it "calls params on nested values" do
+      name     = "Nested"
+      instance = klass.new( name: name )
+      expect( name ).to receive( :params ).and_return "parameterized"
+      expect( instance.params[:name] ).to eq "parameterized"
+    end
+  end
+
+  describe ".for" do
+    let( :namespace ) do
+      Object.send( :remove_const, :EntityModule ) if defined? EntityModule
+      EntityModule = Module.new
+    end
+
+    describe "with 'Entity' class" do
+      let( :entity_class ) do
+        namespace.const_set :ResourceEntity, Class.new( Shamu::Entities::Entity )
+      end
+
+      it "tries Namespace::EntityNameListScope" do
+        klass = Class.new( Shamu::Entities::ListScope )
+        namespace.const_set :ResourceListScope, klass
+        expect( Shamu::Entities::ListScope.for( entity_class ) ).to be klass
+      end
+
+      it "tries Namespace::ListScope" do
+        klass = Class.new( Shamu::Entities::ListScope )
+        namespace.const_set :ListScope, klass
+        expect( Shamu::Entities::ListScope.for( entity_class ) ).to be klass
+      end
+
+      it "falls back to ListScope" do
+        expect( Shamu::Entities::ListScope.for( Shamu::Entities::Entity ) ).to be Shamu::Entities::ListScope
+      end
+    end
+
+    describe "with unadorned entity class" do
+      let( :entity_class ) do
+        namespace.const_set :Resource, Class.new( Shamu::Entities::Entity )
+      end
+
+      it "tries Namespace::EntityNameListScope" do
+        klass = Class.new( Shamu::Entities::ListScope )
+        namespace.const_set :ResourceListScope, klass
+        expect( Shamu::Entities::ListScope.for( entity_class ) ).to be klass
+      end
+
+      it "tries Namespace::ListScope" do
+        klass = Class.new( Shamu::Entities::ListScope )
+        namespace.const_set :ListScope, klass
+        expect( Shamu::Entities::ListScope.for( entity_class ) ).to be klass
+      end
+
+      it "falls back to ListScope" do
+        expect( Shamu::Entities::ListScope.for( Shamu::Entities::Entity ) ).to be Shamu::Entities::ListScope
+      end
+    end
+  end
+
+end

data/spec/lib/shamu/entities/list_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "shamu/entities"
+
+module EntityListSpec
+  class Entity < Shamu::Entities::Entity
+    attribute :id
+    attribute :label
+  end
+end
+
+describe Shamu::Entities::List do
+  let( :first )  { EntityListSpec::Entity.new id: 1, label: :one }
+  let( :second ) { EntityListSpec::Entity.new id: 2, label: :two }
+  let( :source ) { [ first, second ] }
+
+  let( :list ) do
+    Shamu::Entities::List.new( source )
+  end
+
+  describe "#each" do
+    it "is lazy" do
+      raw = [ first, second ]
+      expect( raw ).to receive( :lazy )
+
+      list = Shamu::Entities::List.new( raw )
+      list.to_a
+    end
+
+    it "enumerates over the entities" do
+      expect do |b|
+        list.each( &b )
+      end.to yield_control.twice
+    end
+  end
+
+  describe "#get" do
+    it "finds by id by default" do
+      expect( list.get( 1 ) ).to be first
+    end
+
+    it "finds by custom pk" do
+      expect( list.get( :two, field: :label ) ).to be second
+    end
+
+    it "raises when not found" do
+      expect do
+        list.get( 42 )
+      end.to raise_error Shamu::NotFoundError
+    end
+  end
+
+  describe "short-circuits" do
+    [ :first, :count, :empty? ].each do |method|
+      it "delegates #{ method } to entities" do
+        expect( source ).to receive( method ).and_call_original
+        list.send( method )
+      end
+    end
+  end
+end

data/spec/lib/shamu/entities/null_entity_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+require "shamu/entities"
+
+describe Shamu::Entities::NullEntity do
+  let( :klass ) do
+    Class.new( Shamu::Entities::Entity ) do
+      def self.name
+        "KillerWhale"
+      end
+
+      model :record
+
+      attribute :name, on: :record
+      attribute :email, on: :record
+      attribute :id, on: :record
+      attribute :group do
+        email.present? ? "Emailers" : "Quieters"
+      end
+    end
+  end
+
+  let( :null_klass ) do
+    Class.new( klass ) do
+      include Shamu::Entities::NullEntity
+
+      attribute :group, default: "Uncategorized"
+    end
+  end
+
+  let( :record ) do
+    OpenStruct.new \
+      name: "Killer",
+      email: "star@seaworld.com",
+      id: 5
+  end
+
+  let( :entity ) do
+    klass.new( record: record )
+  end
+
+  let( :null ) do
+    null_klass.new
+  end
+
+  describe "#empty?" do
+    it "is false for real entities" do
+      expect( entity ).not_to be_empty
+    end
+
+    it "is true for null entitites" do
+      expect( null ).to be_empty
+    end
+  end
+
+  describe "attributes" do
+    [ :title, :name, :label ].each do |attr|
+      it "automatically formats '#{ attr }' value with 'Unknown Entity'" do
+        auto_klass = Class.new( klass ) do
+          attribute attr
+        end
+
+        auto_null_klass = Class.new( auto_klass ) do
+          include Shamu::Entities::NullEntity
+        end
+
+        expect( auto_null_klass.new.send( attr ) ).to eq "Unknown Killer Whale"
+      end
+    end
+
+    it "does not automatically format other attributes" do
+      expect( null.email ).to be_nil
+    end
+
+    it "allow auto formatted to be overridden" do
+      auto_null_klass = Class.new( klass ) do
+        include Shamu::Entities::NullEntity
+
+        attribute :name, default: "Missing"
+      end
+
+      expect( auto_null_klass.new.name ).to eq "Missing"
+    end
+  end
+
+  describe ".for" do
+    it "creates a null class" do
+      expect( Shamu::Entities::NullEntity.for( klass ) ).to be < Shamu::Entities::NullEntity
+    end
+
+    it "inherits from the entity class" do
+      expect( Shamu::Entities::NullEntity.for( klass ) ).to be < klass
+    end
+  end
+end

data/spec/lib/shamu/events/active_record/migration_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+require "shamu/active_record"
+
+describe Shamu::Events::ActiveRecord::Migration do
+
+  it "can run" do
+    Shamu::Events::ActiveRecord::Migration.new.migrate( :down )
+    Shamu::Events::ActiveRecord::Migration.new.migrate( :up )
+  end
+
+end

data/spec/lib/shamu/events/active_record/service_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "shamu/active_record"
+
+describe Shamu::Events::ActiveRecord::Service do
+  let( :message ) { Shamu::Events::Message.new }
+  let( :service ) { scorpion.new Shamu::Events::ActiveRecord::Service }
+
+
+  before( :each ) do
+    Shamu::Events::ActiveRecord::Migration.new.migrate( :down )
+    Shamu::Events::ActiveRecord::Migration.new.migrate( :up )
+  end
+
+  it "prepares the database when initialized" do
+    expect( Shamu::Events::ActiveRecord::Service ).to receive( :ensure_records! ).and_call_original
+    scorpion.new Shamu::Events::ActiveRecord::Service
+  end
+
+  describe "#publish" do
+    it "persists the message" do
+      expect do
+        service.publish( "spec", message )
+      end.to change( Shamu::Events::ActiveRecord::Message, :count )
+    end
+
+    it "serializes the message" do
+      expect( service ).to receive( :serialize ).and_call_original
+      service.publish( "spec", message )
+    end
+
+    it "creates a new channel on first publish" do
+      puts Shamu::Events::ActiveRecord::Channel.all
+      expect do
+        service.publish "spec", message
+      end.to change( Shamu::Events::ActiveRecord::Channel, :count )
+    end
+
+    it "re-uses the same channel id for second publish" do
+      service.publish "spec", message
+
+      expect do
+        service.publish "spec", message
+      end.not_to change( Shamu::Events::ActiveRecord::Channel, :count )
+    end
+  end
+
+  describe "#subscribe" do
+    it "receives published messages" do
+      expect do |b|
+        service.publish "spec", message
+        service.subscribe "spec", &b
+        service.dispatch "specs", "spec"
+      end.to yield_control
+    end
+  end
+
+  describe "#dispatch" do
+    before( :each ) do
+      service.publish "spec", message
+    end
+
+    it "keeps track of last processed message" do
+      runner = Shamu::Events::ActiveRecord::Runner.create!( id: "specs::spec" )
+
+      expect do
+        service.dispatch "specs", "spec"
+      end.to change { runner.reload.last_processed_id }
+    end
+
+    it "keeps track of last run" do
+      runner = Shamu::Events::ActiveRecord::Runner.create!( id: "specs::spec" )
+
+      expect do
+        service.dispatch "specs", "spec"
+      end.to change { runner.reload.last_processed_at }
+    end
+
+    it "creates a unique id for each channel" do
+      service.dispatch "specs", "spec"
+
+      expect( Shamu::Events::ActiveRecord::Runner.first.id ).to eq "specs::spec"
+    end
+
+    it "dispatches new message since last run" do
+
+      service.dispatch "specs", "spec"
+      service.publish "spec", Shamu::Events::Message.new
+
+      expect do |b|
+        service.subscribe "spec", &b
+        service.dispatch "specs", "spec"
+      end.to yield_control.once
+    end
+
+
+    it "limits number of messages" do
+      5.times do
+        service.publish "spec", Shamu::Events::Message.new
+      end
+
+      expect do |b|
+        service.subscribe "spec", &b
+        service.dispatch "specs", "spec", limit: 3
+      end.to yield_control.exactly(3)
+    end
+
+    it "returns the number of messages dispatched" do
+      expect( service.dispatch( "specs", "spec" )["spec"] ).to eq 1
+    end
+  end
+
+  describe "#channel_stats" do
+    before( :each ) do
+      service.publish( "spec", message )
+    end
+
+    subject { service.channel_stats( "spec" ) }
+
+    its( [:name] )              { is_expected.to eq "spec" }
+    its( [:subscribers_count] ) { is_expected.to eq 0 }
+    its( [:dispatching] )       { is_expected.to be_falsy }
+    its( [:queue_size] )        { is_expected.to eq 1 }
+
+    context "with runner" do
+      before( :each ) do
+        service.dispatch( "specs", "spec" )
+      end
+
+      subject { service.channel_stats( "spec", runner_id: "specs" ) }
+
+      its( [:name] )              { is_expected.to eq "spec" }
+      its( [:subscribers_count] ) { is_expected.to eq 0 }
+      its( [:dispatching] )       { is_expected.to be_falsy }
+      its( [:queue_size] )        { is_expected.to eq 0 }
+
+    end
+  end
+
+end

data/spec/lib/shamu/events/events_service_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Shamu::Events::EventsService do
+  let( :klass ) do
+    Class.new( Shamu::Events::EventsService ) do
+      public :serialize, :deserialize
+    end
+  end
+  let( :service ) { scorpion.new klass }
+  let( :message ) { Shamu::Events::Message.new }
+
+  it "uses in-memory for default implementation" do
+    expect( scorpion.fetch( Shamu::Events::EventsService ) ).to be_a Shamu::Events::InMemory::Service
+  end
+
+  it "gets the same service for each default scorpion resolution" do
+    service = scorpion.fetch( Shamu::Events::EventsService )
+    expect( scorpion.fetch( Shamu::Events::EventsService ) ).to be service
+  end
+
+  describe "#serialize" do
+    it "generates a string" do
+      expect( service.serialize( message ) ).to be_a String
+    end
+  end
+
+  describe "#deserialize" do
+    it "creates a Message from a string" do
+      data         = service.serialize( message )
+      deserialized = service.deserialize( data )
+
+      expect( deserialized ).to be_a message.class
+      expect( deserialized.id ).to eq message.id
+    end
+  end
+
+  describe ".bridge" do
+    let( :message ) { Shamu::Events::Message.new }
+
+    let( :source_service ) { scorpion.fetch Shamu::Events::InMemory::Service }
+    let( :target_service ) { double Shamu::Events::EventsService }
+
+    before( :each ) do
+      Shamu::Events::EventsService.bridge \
+        source_service,
+        target_service,
+        "spec"
+    end
+
+    it "forwards messages" do
+      expect( target_service ).to receive( :publish )
+
+      source_service.publish "spec", message
+      source_service.dispatch
+    end
+  end
+end