smooth-io 0.0.5

data/spec/lib/collection/query_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe Smooth::Collection::Query do
+  let(:query) { Smooth::Collection::Query.new(key1:"value1", key2:"value2") }
+
+  it "should generate a cache key" do
+    query.cache_key.should == "key1:value1/key2:value2"
+  end
+end

data/spec/lib/collection_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Smooth::Collection do
+  class ModelHelper < Smooth::Model
+    attribute :id, String
+    attribute :name, String
+  end
+
+  let(:collection) { Smooth::Collection.new(namespace: "test", model_class: ModelHelper) }
+
+  before(:all) do
+    5.times {|n| collection.backend.create(name:"Item #{ n }")}
+  end
+
+  it "should set an id on the model when it is saved" do
+    model = collection.add(name:"Item 9")
+    $k = true
+    model.sync
+    $k = false
+
+    model.id.should_not be_nil
+  end
+
+  it "should add a model to the collection but not save it" do
+    model = collection.add(name: "Item 8")
+    model.should be_a(Smooth::Model)
+    model.name.should == "Item 8"
+    model.id.should be_nil
+  end
+
+  it "should have a file backend by default" do
+    collection.backend.should be_a(Smooth::Backends::File)
+  end
+
+  it "should have the concept of a url" do
+  	collection.url.should match(/test/)
+  end
+
+  it "should fetch some models" do
+    collection.fetch()
+    collection.models.should_not be_empty
+  end
+
+  it "should allow me to query it" do
+    collection.query(name: "Item 0").first[:name].should == "Item 0"
+  end
+
+  it "should allow me to reset it" do
+    collection.fetch()
+    collection.reset([{one:1}])
+    collection.length.should == 1
+  end
+
+  it "should support redis backends" do
+    backend = Smooth::Collection.new(backend:"redis",namespace:"test").backend
+    backend.should respond_to(:index)
+  end
+
+  it "should support active record backends" do
+    lambda {
+      Smooth::Collection.new(model: Person)
+    }.should_not raise_error
+  end
+
+  it "should empty the models when resetting" do
+    collection.reset([])
+    collection.models.should be_empty
+  end
+
+  describe "The find methods" do
+    it "should find by id" do
+      collection.find(1).name.should == "Item 0"
+    end
+
+    it "should find by name" do
+      collection.find_by(:name,"Item 0").id.to_i.should == 1
+    end
+  end
+
+  describe "The Sync Interface" do
+    it "should read the models from the collection" do
+      collection.reset([])
+      collection.sync
+      collection.models.length.should >= 5
+    end
+  end
+end

data/spec/lib/examples/cacheable_collection_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "Cacheable Collections" do
+  let(:collection) do  
+    Smooth::Collection.new(backend: "active_record", backend_options:{model:Person}, cache: "redis")
+  end
+
+  let(:hit) do
+    query = Smooth::Collection::Query.new(smooth:"baby",yeah:"son")
+    collection.send(:cache_adapter).write(query.cache_key, "[{id:1}]")
+    query
+  end
+
+  let(:miss) do
+    Smooth::Collection::Query.new(miss:"this",query:"awww")      
+  end
+
+  it "should avoid the backend in a cache hit" do
+    collection.backend.should_not_receive(:query)
+    collection.query(hit)
+  end
+
+  it "should fallback to the backend if there is a cache miss" do
+    collection.backend.should_receive(:query)
+    collection.query(miss)
+  end
+end

data/spec/lib/examples/smooth_model_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+class SmoothModel < Smooth::Model
+  attribute :name, String
+  attribute :age, Integer
+end
+
+describe "The Smooth Model system" do
+  it "should respond to the attribute defined" do
+    model = SmoothModel.new(name:"Jonathan Soeder",age: Time.now.year - 1980)
+    model.name.should == "Jonathan Soeder"
+  end
+end

data/spec/lib/meta_data/application_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Smooth::MetaData::Application do
+  include Rack::Test::Methods
+
+  def app
+    Smooth::MetaData::Application.new
+  end
+
+  class MetaHelperOne < ActiveRecord::Base
+    include Smooth::Queryable
+    include Smooth::Presentable
+    self.table_name = :people
+    can_be_queried_by :name
+  end
+
+  class MetaHelperTwo < ActiveRecord::Base
+    include Smooth::Queryable
+    include Smooth::Presentable
+
+    self.table_name = :people
+    can_be_queried_by :name
+  end
+
+  it "should return a list of resources" do
+    get "/"
+    response = JSON.parse(last_response.body)
+    response.should be_a(Hash)
+    response.keys.should include("MetaHelperOne")
+  end
+
+  it "should show info for a resource" do
+    get "/meta_helper_one"
+    response = JSON.parse(last_response.body)
+    response.keys.should include("queryable")
+    response.keys.should include("presentable")
+  end
+
+  it "should return 404" do
+    get "/supboo"
+    last_response.status.should == 404
+  end
+end

data/spec/lib/meta_data_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Smooth::MetaData do
+
+  class MetaDataHelper < ActiveRecord::Base
+    self.table_name = "people"
+
+    include Smooth::Presentable
+    include Smooth::Queryable
+
+    can_be_queried_by :name
+  end
+
+  let(:meta_data) { Smooth::MetaData["MetaDataHelper"] }
+
+  it "should be able to tell me all of the smooth resources" do
+    Smooth::MetaData.available_resources.should include("MetaDataHelper")
+  end
+
+  it "should tell me all of the presenters for a given resource" do
+    meta_data.presenters.should include(:default)
+  end
+
+  it "should tell me all of the columns a resource can be queried by" do
+    meta_data.queryable_parameters.should include(:name)
+  end
+
+  it "should give me a hash object of all of the query settings" do
+    meta_data.queryable_settings.should be_a(Hash)
+  end
+end
+

data/spec/lib/model_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Smooth::Model do
+
+  class SmoothModelHelper < Smooth::Model
+    attribute :id, String
+    attribute :name, String
+  end
+
+  let(:model) { collection.models[0] || collection.add(name:"Item 1",id:1) }
+
+  let(:collection) do
+    collection = Smooth::Collection.new(namespace:"model:spec",backend:"file", model_class: SmoothModelHelper)
+
+    5.times do |n|
+      id = n + 1
+      collection.backend.create(name:"Item #{ n }", id: id)
+    end
+
+    collection
+  end
+
+  it "should have basic attributes as configured" do
+    SmoothModelHelper.new(name:"sup baby").name.should == "sup baby"
+  end
+
+  it "should read its attributes from the collections data source given an id" do
+    new_model = SmoothModelHelper.new({id:1}, collection: collection)
+    new_model.fetch
+    new_model.name.should == "Item 0"
+  end
+
+  it "should save and update" do
+    model = SmoothModelHelper.new({name:"j-money baby"}, collection: collection)
+    model.name = "sup my boo"
+    model.save
+
+    collection.fetch
+    collection.models.detect {|m| m.name == "sup my boo" }.should be_present
+  end
+
+  it "should save and create" do
+    model = SmoothModelHelper.new({name:"j-money"}, collection: collection)
+    model.save
+
+    collection.models.detect {|m| m.name == "j-money" }.should be_present
+    model.id.to_i.should >= 1
+  end
+
+  it "should delegate its sync method to the collection" do
+    collection.should_receive(:sync)
+    model.sync(:read, {id:1}, {})
+  end
+end

data/spec/lib/presentable/api_endpoint_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Smooth::Presentable::ApiEndpoint do
+  include Rack::Test::Methods
+
+  def app
+    Smooth::Presentable::ApiEndpoint
+  end
+
+
+  class ApiHelper < ActiveRecord::Base
+    self.table_name = :people
+    include Smooth::Presentable
+
+    def sup
+      "hi #{ name }"
+    end
+  end
+
+  class ApiHelperPresenter
+    def self.custom
+      [:name,{key:"sup"}]
+    end
+  end
+
+
+  before(:all) do
+    ApiHelper.delete_all
+    ApiHelper.create(name:"Tahereh")
+  end
+
+  it "should return 404 for an invalid resource" do
+    get "/sup_boo"
+    last_response.status.should == 404
+  end
+
+  it "should allow me to query a resource" do
+    get "/api_helper"
+    last_response.status.should == 200
+    response = JSON.parse(last_response.body)
+    response.should be_a(Array)
+    response.should_not be_empty
+  end
+
+  xit "should allow me to specify a custom presenter" do
+    get "/api_helper/custom"
+
+    last_response.status.should == 200
+    response = JSON.parse(last_response.body)
+    response.should be_a(Array)
+    response.should_not be_empty
+  end
+end
+

data/spec/lib/presentable_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe Smooth::Presentable do
+  before(:all) do
+    Person.send(:include, Smooth::Presentable)
+  end
+
+  it "should register the resource with the smooth metadata registry" do
+    Smooth::MetaData.available_resources.should include("Person")
+  end
+
+  it "should allow me to present a resource as a given format" do
+    records = Person.present({}).as(:default)
+    records.results.should be_a(Array)
+  end
+
+  context "Custom Presenters" do
+    class PresentableHelper < ActiveRecord::Base
+      self.table_name = "people"
+
+      include Smooth::Presentable
+      include Smooth::Queryable
+
+      def friend
+        Friend.new(name:"Jonathan Soeder")
+      end
+    end
+
+    class PresentableHelperPresenter
+      def self.default
+        [:name]
+      end
+
+      def self.custom
+        [
+          :name,
+          {
+            :attribute => :friend,
+            :method => :friend,
+            :presenter => :custom
+          }
+        ]
+      end
+    end
+
+    class Friend < ActiveRecord::Base
+      self.table_name = "people"
+      include Smooth::Presentable
+      include Smooth::Queryable
+    end
+
+    class FriendPresenter
+      def self.custom
+        [:name]
+      end
+    end
+
+    it "should use a role based presenter format if specified" do
+      FriendPresenter.should_receive(:role_custom).at_least(:once)
+      Friend.present({}).as(:custom).to(:role).to_a
+    end
+
+    it "should fall back to the non-role based presenter if there isn't a format specifically defined for the role" do
+      FriendPresenter.should_receive(:custom).at_least(:once)
+      Friend.present({}).as(:custom).to(:default).to_a
+    end
+
+    it "should use the default format if an unknown format is requested" do
+      lambda {
+        PresentableHelper.new(name:"Sup").present_as(:sheeeeit)
+      }.should_not raise_error
+    end
+
+    it "should allow me to nest other presenter calls" do
+      record = PresentableHelper.new(name:"Tupac")
+      presented = record.present_as(:custom)
+      presented[:friend][:name].should == "Jonathan Soeder"
+    end
+  end
+end

data/spec/lib/queryable/converter_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+class MyCollection
+  include Smooth::Queryable
+end
+
+describe Smooth::Queryable do
+
+  describe "Equality" do
+    it "should handle equality" do
+      results = MyCollection.query({title:"Test"});
+    end
+
+    it "should handle equality" do
+      results = MyCollection.query({ title: {"$equal"=>"Test"} });
+    end
+  end
+
+  # MyCollection.query({ colors: {$contains: "red"} });
+  xit "should support $contains" do
+  end
+
+  xit "should support $ne" do
+    MyCollection.query({ title: {"$ne"=>"Test"} })
+  end
+
+  xit "should support $lt" do
+    MyCollection.query({ likes: {"$lt"=>10} })
+  end
+
+  xit "should support $lte" do
+    MyCollection.query({ likes: {"$lte"=>10} })
+  end
+
+  xit "should support $gt" do
+    MyCollection.query({ likes: {"$gt"=>10} })
+  end
+
+  xit "should support $gte" do
+    MyCollection.query({ likes: {"$gte"=>10} })
+  end
+
+  xit "should support $between" do
+    MyCollection.query({ likes: {"$between"=>[5,15] } })
+  end
+
+  xit "should support $in" do
+    MyCollection.query({ title: {"$in"=>["About", "Home", "Contact"] } });
+  end
+
+  xit "should support $nin" do
+    MyCollection.query({ title: { "$nin"=>["About", "Home", "Contact"] } });
+  end
+
+  xit "should support $all" do
+  end
+
+  xit "should support $any" do
+  end
+
+  xit "should support $size" do
+  end
+
+  xit "should support $exists" do
+  end
+
+  xit "should support $has" do
+  end
+
+  xit "should support $like" do
+    MyCollection.query({ title: {"$like"=> "Test"} });
+  end
+
+  xit "should support $likeI" do
+    MyCollection.query({ title: {"$likeI"=> "Test" } });
+  end
+
+  xit "should support $regex" do
+    MyCollection.query({ content: {"$regex"=> /coffeescript/i } });
+  end
+
+  xit "should support $regex" do
+    MyCollection.query({ content: /coffeescript/i });
+  end
+
+  describe "Combined Queries" do
+    xit "should support $and" do
+      MyCollection.query({ "$and"=> { title: {"$like"=> "News"}, likes: {"$gt"=> 10}}});
+      MyCollection.query({ title: {"$like"=> "News"}, likes: {"$gt"=> 10} });
+    end
+
+    xit "should support $or" do
+      MyCollection.query({ "$or"=> { title: { "$like"=> "News"}, likes: { "$gt"=> 10}}});
+    end
+
+    xit "should support $nor" do
+      MyCollection.query({"$nor"=> { title: {"$like"=> "News"}, likes: {"$gt"=> 10}}});
+    end
+
+    xit "should support $not" do
+      MyCollection.query({"$not"=> { title: { "$like"=> "News"}, likes: { "$gt"=> 10}}});
+    end
+  end
+end