ki 0.3.3 → 0.4.1

data/spec/examples/json.northpole.ro/views/python.haml

@@ -0,0 +1,17 @@
+%pre.code.python
+  = preserve do
+    :escaped
+      import requests
+      import json
+
+      API_KEY = '#{NP_GUEST_API_KEY}'
+      SECRET = '#{NP_GUEST_SECRET}'
+      URL = '#{NP_URL}/storage.json'
+
+      result = requests.post(URL, params = {'#{NP_API_KEY}': API_KEY, '#{NP_SECRET}': SECRET, 'foo': 'bar'})
+      resource = json.loads(result.text)
+      resource_id = resource['id']
+
+      requests.get(URL, params = {'#{NP_API_KEY}': API_KEY, '#{NP_SECRET}': SECRET, 'id': resource_id})
+      requests.put(URL, params = {'#{NP_API_KEY}': API_KEY, '#{NP_SECRET}': SECRET, 'id': resource_id, 'foo': 'not bar'})
+      requests.delete(URL, params = {'#{NP_API_KEY}': API_KEY, '#{NP_SECRET}': SECRET, 'id': resource_id})

data/spec/examples/json.northpole.ro/views/ruby.haml

@@ -0,0 +1,12 @@
+%pre.code
+  = preserve do
+    :escaped
+      require 'uri'
+      require 'net/http'
+      require 'json'
+
+      uri = URI.parse("#{NP_URL}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Post.new("/storage.json")
+      request.body = {'#{NP_API_KEY}' => '#{NP_SECRET}', '#{NP_GUEST_API_KEY}' => '#{NP_GUEST_SECRET}'}.to_json
+      response = http.request(request)

data/spec/examples/json.northpole.ro/views/signup.haml

@@ -0,0 +1,2 @@
+%input#user{ :type => 'text', :placeholder => 'api_key' }
+%input#pass{ :type => 'text', :placeholder => 'secret' }

data/spec/examples/json.northpole.ro/views/thanks.haml

@@ -0,0 +1,12 @@
+%p
+  = other_developer_count
+%br
+%p
+  Thanks Gabi Nagy for
+  %a{:href => 'https://github.com/northpole-api/northpole.ro/blob/master/public/favicon.ico'} the favicon
+%p
+  Thanks Rares Musina for
+  %a{:href => 'https://github.com/northpole-api/NorthPoleNetWrapper'} NorthPoleNetWrapper
+%p
+  Thanks for
+  %a{:href => 'http://openclipart.org/detail/97081/polar-bear-by-aguasas'} the bear

data/spec/functional_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe 'the app' do
+end

data/spec/lib/ki/base_request_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Ki::BaseRequest do
+  let(:req) { Ki::BaseRequest }
+
+  it 'knows if current path is root' do
+    req.new({'PATH_INFO' => '/'}).root?.should be_true
+    req.new({'PATH_INFO' => '/foo'}).root?.should be_false
+  end
+
+  it 'coverts path to class' do
+    class Foo < Ki::Model; end
+    class Bar < Ki::Model; end
+    req.new({'PATH_INFO' => ''}).to_ki_model_class.should == nil
+    req.new({'PATH_INFO' => '/'}).to_ki_model_class.should == nil
+    req.new({'PATH_INFO' => 'foo'}).to_ki_model_class.should == Foo
+    req.new({'PATH_INFO' => '/foo'}).to_ki_model_class.should == Foo
+    req.new({'PATH_INFO' => '/Foo.json'}).to_ki_model_class.should == Foo
+    req.new({'PATH_INFO' => '/bar.json'}).to_ki_model_class.should == Bar
+    req.new({'PATH_INFO' => '/Foo/bar.json'}).to_ki_model_class.should == nil
+    req.new({'PATH_INFO' => '/Foo/bar'}).to_ki_model_class.should == nil
+    req.new({'PATH_INFO' => '/Foo_bar'}).to_ki_model_class.should == nil
+  end
+
+  it 'converts verb to action' do
+    req.new({'REQUEST_METHOD' => 'GET'}).to_action.should == :find
+    req.new({'REQUEST_METHOD' => 'POST'}).to_action.should == :create
+    req.new({'REQUEST_METHOD' => 'PUT'}).to_action.should == :update
+    req.new({'REQUEST_METHOD' => 'DELETE'}).to_action.should == :delete
+    req.new({'REQUEST_METHOD' => 'SEARCH'}).to_action.should == :find
+  end
+
+  context 'json' do
+    it 'considers application/json content type as a json request' do
+      req.new({'CONTENT_TYPE' => 'application/xml'}).json?.should be_false
+      req.new({}).json?.should be_false
+      req.new({'CONTENT_TYPE' => 'application/json'}).json?.should be_true
+    end
+
+    it 'considers .json url format as a json request' do
+      req.new({'PATH_INFO' => '/foo'}).json?.should be_false
+      req.new({'PATH_INFO' => '/foo.json'}).json?.should be_true
+    end
+
+    # context 'params' do
+    #   it 'handles get with no params' do
+    #     asd = req.new({
+    #       'PATH_INFO' => "/foo.json",
+    #       'QUERY_STRING' => '',
+    #       'REQUEST_METHOD' => 'GET',
+    #       'rack.input' => ''
+    #     })
+    #     asd.params.should == {}
+    #   end
+
+    #   it 'handles query params' do
+    #     asd = req.new({
+    #       'PATH_INFO' => "/foo.json",
+    #       'QUERY_STRING' => 'foo=bar&cez[]=dar&cez[]=asd',
+    #       'REQUEST_METHOD' => 'GET',
+    #       'rack.input' => ''
+    #     })
+    #     asd.params.should == {'foo' => 'bar', 'cez' => ['dar', 'asd']}
+    #   end
+
+    #   it 'handles both query and body params' do
+    #     # asd = req.new({
+    #     #   'PATH_INFO' => "/foo.json",
+    #     #   'QUERY_STRING' => 'foo=bar&cez[]=dar&cez[]=asd',
+    #     #   'REQUEST_METHOD' => 'POST',
+    #     #   'rack.input' => '{"bar":"foo"}'
+    #     # })
+
+    #     asd = StringIO.new
+    #     asd << '{"bar":"foo"}'
+
+    #     env = Rack::MockRequest.env_for('foo.json', {
+    #       'REQUEST_METHOD' => 'POST',
+    #       'QUERY_STRING' => 'foo=bar&cez[]=dar&cez[]=asd',
+    #       :input => asd
+    #     })
+    #     asd = req.new(env)
+    #     # p asd.body.read
+    #     # Foo.new(asd)
+    #   end
+    # end
+  end
+end

data/spec/lib/ki/helpers_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Ki::Helpers do
+  include Ki::Helpers
+
+  it 'should render_haml' do
+    render_haml('%div.foo').should == "<div class='foo'></div>\n"
+  end
+
+  it 'should render a partial' do
+  end
+end

data/spec/lib/ki/ki_config_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Ki::KiConfig do
+  it 'should know db name in test env' do
+    Ki::KiConfig.instance.environment.should == 'test'
+  end
+end

data/spec/lib/ki/middleware_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Ki::Middleware do
+  context Ki::Middleware::ApiHandler do
+    it 'should only handle urls maped from objects that extend Ki::Model' do
+      get '/asd.json'
+      JSON.parse(last_response.body)
+      last_response.status.should == 404
+    end
+  end
+end

data/spec/lib/ki/model_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Ki::Model do
+  before :all do
+    class Foo < Ki::Model; end
+    class Bar < Ki::Model; end
+  end
+
+  it "should know about all descendants" do
+    desc = Ki::Model.descendants
+    desc.include?(Foo).should be_true
+    desc.include?(Bar).should be_true
+  end
+
+  context Ki::QueryInterface do
+    it 'should have the query interface' do
+      Foo.class_name.should == 'Foo'
+      expect {
+        id = Foo.create({hello: 'world'})['id']
+        Foo.find(id).first['hello'].should == 'world'
+        Foo.update('id' => id, 'hello' => 'universe')
+        Foo.find(id).first['hello'].should == 'universe'
+        Foo.delete(id)
+      }.to change{Foo.count}.by 0
+    end
+
+    it 'should find or create' do
+      expect {
+        h = { 'time' => Time.now.to_i.to_s }
+        r = Foo.find_or_create(h)
+        r = Foo.find_or_create(h)
+      }.to change { Foo.count }.by 1
+    end
+  end
+
+  it 'should have restrictions configured' do
+    Bar.unique_attributes.should == []
+    Bar.required_attributes.should == []
+    Bar.forbidden_actions.should == []
+
+    class Bar < Ki::Model
+      unique :foo
+      requires :foo
+      forbid :delete
+    end
+
+    Bar.unique_attributes.should == [:foo]
+    Bar.required_attributes.should == [:foo]
+    Bar.forbidden_actions.should == [:delete]
+  end
+
+  context 'default properties' do
+    class DefaultProperties < Ki::Model
+    end
+
+    it 'should create object' do
+      expect {
+        DefaultProperties.new(:create, { 'name' => 'zim' })
+      }.to change { DefaultProperties.count }.by 1
+    end
+  end
+
+  context 'required, unique, forbid' do
+    class SpecialProperties < Ki::Model
+      unique :foo
+      requires :foo
+      forbid :delete
+    end
+
+    it 'should create object' do
+      t = Time.now.to_i
+      # keep in mind that delete does not call unique/requires/forbid filters
+      # make sure there are no duplicates
+      SpecialProperties.delete({'foo' => t})
+      expect {
+        SpecialProperties.new(:create, { 'name' => 'zim', 'foo' => t })
+      }.to change { SpecialProperties.count }.by 1
+    end
+
+    it 'should check for required attributes' do
+      expect {
+        SpecialProperties.new(:create, { 'name' => 'zim' })
+      }.to raise_error Ki::RequiredAttributeMissing
+    end
+
+    it 'should check for unique attributes' do
+      expect {
+        t = Time.now.to_i
+        SpecialProperties.new(:create, { 'name' => 'zim', 'foo' => t })
+        SpecialProperties.new(:create, { 'name' => 'zim', 'foo' => t })
+      }.to raise_error Ki::AttributeNotUnique
+    end
+
+    it 'should not allow forbidden actions' do
+      expect {
+        SpecialProperties.new(:delete, {})
+      }.to raise_error Ki::ForbiddenAction
+    end
+  end
+end

data/spec/lib/ki/modules/format_of_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ki::FormatOf do
+  let(:obj) { @obj = Object.new; @obj.extend(Ki::FormatOf) }
+
+  it 'should parse url format' do
+    [nil, {}, '', '.json'].each do |s|
+      obj.format_of(s).should == ''
+    end
+
+    ['asd.json', 'asd.json?asd=1'].each do |s|
+      obj.format_of(s).should == 'json'
+    end
+  end
+end

data/spec/lib/ki/orm_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ki::Orm do
+  before :all do
+    @db = Ki::Orm::Db.instance.establish_connection
+  end
+
+  it 'should know db name in test env' do
+    @db.config['name'].should == 'np_test'
+  end
+
+  it 'should create a db object' do
+    expect {
+      oid = @db.insert 'foo', {hello: 'world'}
+      oid.class.should == Hash
+    }.to change{@db.count('foo')}.by(1)
+  end
+
+  context 'count' do
+    it 'should count' do
+      expect {
+        @db.insert 'foo', {hello: 'world'}
+      }.to change{@db.count('foo')}.by(1)
+    end
+
+    it 'should count by hash' do
+      t = Time.now.to_i.to_s
+      expect {
+        @db.insert 'foo', {hello: t}
+      }.to change{@db.count('foo', {hello: t})}.by(1)
+    end
+  end
+
+  context 'find' do
+    it 'should find all' do
+      @db.insert 'foo', {hello: 'world'}
+      @db.insert 'foo', {hello: 'world'}
+      @db.find('foo').to_a.count.should >= 2
+    end
+
+    it 'should find by string id' do
+      obj_id = @db.insert('foo', {hello: 'world'})['id']
+      @db.find('foo', obj_id).first['id'].should == obj_id
+    end
+
+    it 'should find by hash["id"]' do
+      obj_id = @db.insert 'foo', {'hello' => 'world'}
+      @db.find('foo', {'id' => obj_id['id']}).first.should == obj_id
+    end
+
+    it 'should find by hash["_id"]' do
+      obj_id = @db.insert('foo', {hello: 'world'})['id']
+      @db.find('foo', {'_id' => obj_id}).first['id'].should == obj_id
+    end
+
+    it 'should find by BSON::ObjectId(id)' do
+      obj_id = @db.insert('foo', {'hello' => 'world'})['id']
+      @db.find('foo', {'id' => BSON::ObjectId(obj_id)}).first['id'].should == obj_id
+      @db.find('foo', {'_id' => BSON::ObjectId(obj_id)}).first['id'].should == obj_id
+    end
+
+    it 'should return empty array when nothing found' do
+      r = @db.find('foo', {'it does not exist' => 'sure hope so' + Time.now.to_i.to_s })
+      r.class.should == Array
+      r.should be_empty
+    end
+  end
+
+  it 'should update' do
+    obj_id = @db.insert('foo', { 'hello' => 'world' })['id']
+    @db.find('foo', obj_id).first['hello'].should == 'world'
+    up = @db.update('foo', { 'id' => obj_id, 'hello' => 'universe' })['id']
+    up.should == obj_id
+    @db.find('foo', obj_id).first['hello'].should == 'universe'
+  end
+
+  it 'should delete by id' do
+    obj_id = @db.insert 'foo', { 'hello' => 'world' }
+    expect {
+      @db.delete('foo', obj_id).should == {}
+    }.to change { @db.count 'foo' }.by -1
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,24 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
+ENV['RACK_ENV'] = 'test'
+
+require 'rack/test'
+include Rack::Test::Methods
+
 require 'ki'
 
-DB_NAME = 'ki_test_db'
-Ki::Conf.instance.yaml['database_name'] = DB_NAME
-Ki::Db.instance.config
+Ki::KiConfig::CONFIG_FILE_PATH = 'spec/examples/base/config.yml'
+Ki::KiConfig.instance.read 'test'
+Ki::Orm::Db.instance.establish_connection
 
+def app
+  Ki::Ki.new
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
 end

data/spec/util_spec.rb

@@ -1,41 +1,12 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
-def format s, output
-  Ki::Util.format(s).should == output
-end
-
-def base s, output
-  Ki::Util.base(s).should == output
-end
-
-describe Ki::Util do
-  it "should parse format correctly" do
-    format '/', :html
-    format '/index', :html
-    format '/index.html', :html
-    format '/index.html?asd=1', :html
-    format '/index?asd=1', :html
-    format '/john?asd=', :html
-    format '/asd?asd=1&bar=2', :html
-    format '/welcome.json', :json
-    format '/welcome.json?foo', :json
-    format '/welcome.json?foo=1&ar=2', :json
-  end
-
-  it "should get the base url correctly" do
-    base '/', ''
-    base '/index', 'index'
-    base '/foo?bar=1', 'foo'
-    base '/asd/bar', 'asd'
-    base '/asd.json', 'asd'
-    base '/foo.html', 'foo'
+describe Ki do
+  it 'should run in test env' do
+    Ki::Ki.new.environment.should == 'test'
   end
 
-  it "should correctly convert to a class" do
-    "dog".to_class.should == nil
-    class Dog
-    end
-    "dog".to_class.should == Dog
-    "cat".to_class.should == nil
+  it 'should convert string to class corectly' do
+    class Cez; end
+    'cez'.to_class.should == Cez
   end
 end