ki 0.3.3 → 0.4.1

data/spec/integration/integration_spec.rb

@@ -1,114 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-def encrypt s
-  s + '!'
-end
-
-describe 'Integration Tests' do
-  before :each do
-    @db = Ki::Db.instance
-    @db.remove_collections
-  end
-
-  it "should handle user and storage" do
-    class User < Ki::Model
-      requires :mail, :password
-      respond_to :json
-      forbid :delete, :update
-      unique :mail
-
-      def before_all
-        params['password'] = encrypt(params['password']) if params['password']
-      end
-    end
-
-    class Storage < Ki::Model
-      respond_to :json
-      requires :mail, :all_my_data
-
-      def before_all
-        ensure_authorization
-      end
-
-      private
-
-      def ensure_authorization
-        if params['mail'].nil? || params['password'].nil?
-          raise 'not authorized'
-        end
-        h = { 'mail' => params['mail'], 'password' => encrypt(params['password'])}
-        u = User.find(h)
-        if u.empty?
-          raise 'not authorized'
-        end
-        params.delete('password')
-      end
-    end
-
-    expect {
-      User.new(Ki::ReqFactory.new(:post, { 'mail' => 'cool@beans.com'})).hash['id']
-    }.to raise_error 'password missing'
-
-    expect {
-      id = User.new(Ki::ReqFactory.new(:post, { 'mail' => 'cool@beans.com', 'password' => '123'})).hash['id']
-      User.new(Ki::ReqFactory.new(:get, { 'id' => id })).hash[0]['password'].should == '123!'
-    }.to change(User, :count).by(1)
-
-    expect {
-      id = User.new(Ki::ReqFactory.new(:post, { 'mail' => 'cool@beans.com', 'password' => '123'})).hash['id']
-    }.to raise_error 'mail not unique'
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:post, {}))
-    }.to raise_error 'not authorized'
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:post, {'mail' => 'cool@beans.com'}))
-    }.to raise_error 'not authorized'
-
-    # create storage
-    storage = Storage.new(Ki::ReqFactory.new(:post, {'mail' => 'cool@beans.com', 'password' => '123', 'all_my_data' => [1,2,3]}))
-    id = storage.hash['id']
-    r = Storage.new(Ki::ReqFactory.new(:get, { 'mail' => 'cool@beans.com', 'password' => '123'}))
-    r.hash[0]['all_my_data'].should == [1,2,3]
-    r.hash[0]['password'].should == nil
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:delete, {}))
-    }.to raise_error 'not authorized'
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:delete, {'id' => id}))
-    }.to raise_error 'not authorized'
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:delete, {'mail' => 'cool@beans.com', 'password' => '123'}))
-    }.to raise_error 'param id missing'
-
-    # delete from storage
-    expect {
-      Storage.new(Ki::ReqFactory.new(:delete, {'id' => id, 'mail' => 'cool@beans.com', 'password' => '123'}))
-    }.to change(Storage, :count).by(-1)
-
-    # not allowed to delete user
-    expect {
-      id = User.new(Ki::ReqFactory.new(:post, { 'mail' => 'other@beans.com', 'password' => '123'})).hash['id']
-      p User.new(Ki::ReqFactory.new(:delete, { 'id' => id }))
-    }.to raise_error 'action forbidden'
-
-    storage = Storage.new(Ki::ReqFactory.new(:post, {'mail' => 'cool@beans.com', 'password' => '123', 'all_my_data' => [4,4,5]}))
-    id = storage.hash['id']
-    expect {
-      Storage.new(Ki::ReqFactory.new(:put, {'mail' => 'cool@beans.com', 'password' => '123', 'all_my_data' => [1]}))
-    }.to raise_error 'param id missing'
-
-    expect {
-      Storage.new(Ki::ReqFactory.new(:put, {'mail' => 'cool@beans.com', 'password' => '1234', 'all_my_data' => [1]}))
-    }.to raise_error 'not authorized'
-
-    storage = Storage.new(Ki::ReqFactory.new(:put, {'id' => id, 'mail' => 'cool@beans.com', 'password' => '123', 'all_my_data' => [1]}))
-    storage.hash['id'].should == id
-    storage = Storage.find(id)
-    storage['all_my_data'].should == [1]
-  end
-end

data/spec/ki_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Ki do
-  it "should work" do
-    1.should == 1
-  end
-end

data/spec/model_spec.rb

@@ -1,91 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Ki::Model do
-  before :each do
-    class Zoidberg < Ki::Model
-    end
-    @db = Ki::Db.instance
-    @db.remove_collections
-  end
-
-  it "should correctly extract class_name" do
-    # Zoidberg.new(@get).class_name.should == "zoidberg"
-  end
-
-  it "should create a new item in the databse" do
-    post = Ki::ReqFactory.new(:post_homer)
-    @db.db['zoidberg'].count.should == 0
-    hash = Zoidberg.new(post).hash
-    @db.db['zoidberg'].count.should == 1
-    @db.find('zoidberg', hash['id'])['user'].should == 'homer'
-  end
-
-  it "should get a model depending on id" do
-    id = @db.create 'zoidberg', { :name => 'homer' }
-
-    get = Ki::ReqFactory.new(:get, {'id' => id})
-    Zoidberg.new(get).hash[0]['name'].should == 'homer'
-  end
-
-  it "should find objects depending on params" do
-    @db.create 'zoidberg', { :name => 'homer', :valid => true }
-    @db.create 'zoidberg', { :name => 'bart', :valid => true }
-    @db.create 'zoidberg', { :name => 'batman', :valid => false, :cool => true }
-    @db.create 'zoidberg', { :name => 'joker', :valid => false, :cool => true }
-    @db.create 'zoidberg', { :name => 'joker', :valid => false, :cool => false }
-
-    r = Zoidberg.new(Ki::ReqFactory.new(:get, { :name => 'homer' })).hash
-    r[0]['name'].should == 'homer'
-
-    r = Zoidberg.new(Ki::ReqFactory.new(:get, { :valid => true })).hash
-    r.length.should == 2
-
-    r.collect { |z|
-      z['valid'].should be_true
-    }
-
-    r = Zoidberg.new(Ki::ReqFactory.new(:get, { :valid => false, :cool => true })).hash
-    r.length.should == 2
-  end
-
-  it "should only accept valid object ids" do
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:get_with_params, { :id => 'homer' }))
-    }.to raise_error
-  end
-
-  it "should update a document" do
-    id = @db.create 'zoidberg', { :name => 'homer' }
-    @db.find('zoidberg', id)['name'].should == 'homer'
-
-    Zoidberg.new(Ki::ReqFactory.new(:put, {'id' => id, :name => 'bart'}))
-    @db.find('zoidberg', id)['name'].should == 'bart'
-  end
-
-  it "should raise error if id is missing when updating" do
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:put, {:name => 'bart'}))
-    }.to raise_error
-  end
-
-  it "should raise error if id is invalid" do
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:put, {'id' => 'f*ck', :name => 'bart'}))
-    }.to raise_error
-  end
-
-  it "should delete a document" do
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:delete))
-    }.to raise_error
-
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:delete, {'id' => 'f*ck', :name => 'bart'}))
-    }.to raise_error
-
-    id = @db.create 'zoidberg', { :name => 'homer' }
-    expect {
-      Zoidberg.new(Ki::ReqFactory.new(:delete, {'id' => id}))
-    }.to change(@db.db['zoidberg'], :count).by(-1)
-  end
-end

data/spec/modules/callbacks_spec.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ki::Callbacks do
-  it "should have before and after find" do
-    class Foo < Ki::Model
-      def before_create
-        @req.params['meaning_of_life'] = 42
-      end
-    end
-
-    id = Foo.new(Ki::ReqFactory.new(:post, {:foo => 'bar'})).hash['id']
-    Foo.new(Ki::ReqFactory.new(:get, { 'id' => id })).hash[0]['meaning_of_life'].should == 42
-  end
-
-  it "should handle before and after all" do
-    class Foo < Ki::Model
-      def before_all
-        params[:cool] = true unless get?
-      end
-    end
-
-    id = Foo.new(Ki::ReqFactory.new(:post, {:foo => 'bar'})).hash['id']
-    Foo.new(Ki::ReqFactory.new(:get, { 'id' => id })).hash[0]['cool'].should be_true
-  end
-end

data/spec/modules/email_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ki::Email do
-  it "should validate email properly" do
-    extend Ki::Email
-
-    valid_mail?('asd').should be_false
-    valid_mail?('asd.asd').should be_false
-    valid_mail?('').should be_false
-    valid_mail?(nil).should be_false
-    valid_mail?('asda@asdasd').should be_false
-    valid_mail?('cool$#Q!@asd.com').should be_false
-
-    valid_mail?('cool1@gmail.com').should be_true
-    valid_mail?('cool@gmail.co').should be_true
-    valid_mail?('cool@gmail.co.uk').should be_true
-    valid_mail?('cool+beans@gmail.com').should be_true
-  end
-end

data/spec/modules/query_interface_spec.rb

@@ -1,93 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ki::QueryInterface do
-  before :each do
-    @db = Ki::Db.instance
-    @db.remove_collections
-  end
-
-  it "should find waldo" do
-    id = @db.create 'waldo', { :location => 'amsterdam' }
-
-    class Waldo < Ki::Model
-    end
-
-    waldo = Waldo.find(id)
-    waldo['location'].should == 'amsterdam'
-  end
-  
-  it "should find by a hash" do
-    @db.create 'waldo', { :location => 'amsterdam', :cool => true, :value => 0 }
-    @db.create 'waldo', { :location => 'copenhagen', :cool => true, :value => 1 }
-    @db.create 'waldo', { :location => 'kronstadt', :cool => true, :value => 1 }
-
-    class Waldo < Ki::Model
-    end
-
-    r = Waldo.find({ :cool => true })
-    r.length.should == 3
-
-    r = Waldo.find({ :cool => true, :value => 1 })
-    r.length.should == 2
-  end
-
-  it "should delete porn" do
-    id = @db.create 'porn', { :website => 'youporn.com' }
-
-    class Porn < Ki::Model
-    end
-
-    expect {
-      Porn.delete(id)
-    }.to change(@db.db['porn'], :count).by(-1)
-  end
-
-  it "should count sheep" do
-    class Sheep < Ki::Model
-    end
-
-    Sheep.count.should == 0
-    expect {
-      @db.create 'sheep', { :wool => 'green' }
-    }.to change(Sheep, :count).by(1)
-    Sheep.count.should == 1
-  end
-
-  it "should create the universe in 7 days" do
-    class Universe < Ki::Model
-    end
-
-    universe = { :water => true }
-    Universe.count.should == 0
-    expect {
-      id = Universe.create universe
-      Universe.find(id)['water'].should be_true
-    }.to change(Universe, :count).by(1)
-  end
-
-  it "should update all the software" do
-    class Software < Ki::Model
-    end
-
-    id = Software.create({ :version => 1.1 })
-    expect {
-      Software.update({'id' => id, :version => 1.2})
-      Software.find(id)['version'].should == 1.2
-    }.to change(Software, :count).by(0)
-  end
-
-  it "should find or create" do
-    class Crab < Ki::Model
-    end
-    hash = {'user' => 'name', 'birth' => '2015'}
-
-    Crab.find(hash).empty?.should be_true
-    expect {
-      Crab.find_or_create hash
-    }.to change(Crab, :count).by(1)
-
-    expect {
-      Crab.find_or_create hash
-    }.to change(Crab, :count).by(0)
-  end
-end

data/spec/modules/restrictions_spec.rb

@@ -1,110 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ki::Restrictions do
-  before :each do
-    @db = Ki::Db.instance
-    @db.remove_collections
-  end
-
-  it "should only allow specified methods" do
-    class Foo < Ki::Model
-    end
-    expect {
-      Foo.new(Ki::ReqFactory.new(:head))
-    }.to raise_error
-  end
-
-  it "should not have any restrictions by default" do
-    class Foo < Ki::Model
-    end
-    Foo.forbidden_actions.empty?.should be_true
-    Foo.new(Ki::ReqFactory.new(:post_homer))
-  end
-
-  it "should restrict search when find is forbidden" do
-    class Foo < Ki::Model
-      forbid :find
-    end
-    expect {
-      Foo.new(Ki::ReqFactory.new(:search, {'foo' => 'bar'} ))
-    }.to raise_exception
-  end
-
-  it "should only restrict :delete" do
-    class Foo < Ki::Model
-      forbid :delete
-    end
-    Foo.forbidden_actions.include?(:delete).should be_true
-    id = Foo.new(Ki::ReqFactory.new(:post_homer)).hash['id']
-    expect {
-      Foo.new(Ki::ReqFactory.new(:delete, { 'id' => id } ))
-    }.to raise_exception
-  end
-
-  it "should respond to html and json by default" do
-    class Foo < Ki::Model
-    end
-    Foo.responds_to_formats.should == [:json, :html]
-  end
-
-  it "should allow only json" do
-    class Foo < Ki::Model
-      respond_to :json
-    end
-    Foo.responds_to_formats.include?(:json).should be_true
-    Foo.responds_to_formats.include?(:html).should be_false
-  end
-
-  it "should not have any required attributes" do
-    class Foo < Ki::Model
-    end
-    Foo.required_attributes.empty?.should be_true
-  end
-
-  it "should require name" do
-    class Foo < Ki::Model
-      requires :name
-    end
-    Foo.required_attributes.include?(:name).should be_true
-
-    expect {
-      Foo.new(Ki::ReqFactory.new(:post_homer))
-    }.to raise_exception
-
-    expect {
-      Foo.new(Ki::ReqFactory.new(:post, {'name' => 'bart' }))
-    }.to change(Ki::Db.instance.db['foo'], :count).by(1)
-  end
-
-  it "should handle unique attributes" do
-    class Foo < Ki::Model
-    end
-    Foo.unique_attributes.should == []
-
-    class Bar < Ki::Model
-      unique :foo
-    end
-    Bar.unique_attributes.should == [:foo]
-
-    expect {
-      Bar.new(Ki::ReqFactory.new(:post, { 'foo' => 'bar'}))
-    }.to change(Bar, :count).by(1)
-
-    expect {
-      Bar.new(Ki::ReqFactory.new(:post, { 'foo' => 'bar'}))
-    }.to raise_error 'foo not unique'
-  end
-
-  it "should default to :layout" do
-    class Foo < Ki::Model
-    end
-    Foo.selected_layout.should == :layout
-  end
-
-  it "should chage default layout" do
-    class Foo < Ki::Model
-      layout :none
-    end
-    Foo.selected_layout.should == :none
-  end
-end