datacatalog 0.1.0 → 0.2.3

data/lib/resources/about.rb

@@ -0,0 +1,11 @@
+module DataCatalog
+
+  class About < Base
+    
+    def self.get()
+      one(http_get("/"))
+    end
+    
+  end
+  
+end

data/lib/resources/api_key.rb

@@ -0,0 +1,38 @@
+module DataCatalog
+
+  class ApiKey < Base
+    
+    def self.all(user_id, conditions={})
+      many(http_get(uri(user_id), :query => conditions))
+    end
+
+    def self.create(user_id, params={})
+      one(http_post(uri(user_id), :query => params))
+    end
+
+    def self.destroy(user_id, id)
+      one(http_delete(uri(user_id, id)))
+    end
+
+    def self.first(user_id, conditions={})
+      one(http_get(uri(user_id), :query => conditions).first)
+    end
+
+    def self.get(user_id, id)
+      one(http_get(uri(user_id, id)))
+    end
+    
+    def self.update(user_id, id, params={})
+      one(http_put(uri(user_id, id), :query => params))
+    end
+    
+    # == Helpers
+    
+    def self.uri(user_id, id = nil)
+      raise Error, "user_id cannot be blank" if user_id.blank?
+      "/users/#{user_id}/keys/#{id}"
+    end
+    
+  end
+
+end

data/lib/resources/source.rb

@@ -0,0 +1,31 @@
+module DataCatalog
+
+  class Source < Base
+    
+    def self.all(conditions={})
+      many(http_get("/sources", :query => conditions))
+    end
+
+    def self.create(params={})
+      one(http_post("/sources", :query => params))
+    end
+
+    def self.destroy(source_id)
+      one(http_delete("/sources/#{source_id}"))
+    end
+    
+    def self.first(conditions={})
+      one(http_get("/sources", :query => conditions).first)
+    end
+
+    def self.get(id)
+      one(http_get("/sources/#{id}"))
+    end
+    
+    def self.update(source_id, params={})
+      one(http_put("/sources/#{source_id}", :query => params))
+    end
+
+  end
+  
+end

data/lib/resources/user.rb

@@ -0,0 +1,73 @@
+module DataCatalog
+
+  class User < Base
+    
+    def self.all(conditions={})
+      many(http_get("/users", :query => conditions))
+    end
+
+    def self.create(params={})
+      with_api_keys(one(http_post("/users", :query => params)))
+    end
+
+    def self.destroy(user_id)
+      one(http_delete("/users/#{user_id}"))
+    end
+
+    def self.first(conditions={})
+      one(http_get("/users", :query => conditions).first)
+    end
+    
+    def self.get(id)
+      with_api_keys(one(http_get("/users/#{id}")))
+    end
+
+    def self.get_by_api_key(api_key)
+      DataCatalog.with_key(api_key) do
+        checkup = one(http_get("/checkup"))
+        raise NotFound unless checkup.valid_api_key
+        get(checkup.user.id)
+      end
+    end
+    
+    def self.update(user_id, params)
+      one(http_put("/users/#{user_id}", :query => params))
+    end
+
+    # == Helpers
+    
+    def self.with_api_keys(user)
+      user.api_keys = ApiKey.all(user.id) if user
+      user
+    end
+    
+    # == Instance Methods
+
+    def delete_api_key!(api_key_id)
+      ApiKey.destroy(self.id, api_key_id)
+      update_api_keys
+    end
+
+    def generate_api_key!(params)
+      ApiKey.create(self.id, params)
+      update_api_keys
+    end
+
+    def update_api_key!(api_key_id, params)
+      ApiKey.update(self.id, api_key_id, params)
+      update_api_keys
+    end
+    
+    protected
+    
+    def update_api_keys
+      self.api_keys = ApiKey.all(self.id)
+      user = User.get(id)
+      self.application_api_keys = user.application_api_keys
+      self.valet_api_keys = user.valet_api_keys
+      true
+    end
+    
+  end
+
+end

data/sandbox_api.yml.example

@@ -1,2 +1,2 @@
-api_key: d193d1523d49e4caf46297ef94d7a2c995d3b2cb # generate with rake db:ensure_admin on datacatalog-api
-base_uri: sandbox.dc-api.local
+api_key: d193d1523d49e4caf46297ef94d7a2c995d3b2cb # generate with rake db:ensure_admin on datacatalog-api
+base_uri: sandbox.dc-api.local

data/spec/about_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+include DataCatalog
+
+describe DataCatalog do
+
+  describe ".about" do
+    before do
+      setup_api
+    end
+
+    it "should return information about the API" do
+      about = About.get
+      about.should be_an_instance_of(About)
+      about.name.should == "National Data Catalog API"
+      about.project_page.should == {
+        "href" => "http://sunlightlabs.com/projects/datacatalog/"
+      }
+    end
+  end
+
+end

data/spec/api_key_spec.rb

@@ -1 +1,145 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/spec_helper'
+include DataCatalog
+
+module ApiKeyHelpers
+  def create_user
+    User.create({
+      :name  => "Ted Smith",
+      :email => "ted@email.com"
+    })
+  end
+  
+  def create_user_with_2_keys
+    user = create_user
+    ApiKey.create(user.id, {
+      :purpose  => "Civic hacking",
+      :key_type => "application"
+    })
+    User.get(user.id)
+  end
+end
+
+describe ApiKey do
+  include ApiKeyHelpers
+
+  before do
+    setup_api
+    clean_slate
+  end
+
+  describe ".all" do
+    before do
+      @user = create_user_with_2_keys
+      @api_keys = ApiKey.all(@user.id)
+    end
+  
+    it "should return an enumeration of API keys" do
+      @api_keys.each do |api_key|
+        api_key.should be_an_instance_of(ApiKey)
+      end
+    end
+  
+    it "should return correct titles" do
+      @api_keys.map(&:key_type).should == %w(primary application)
+    end
+  end
+
+  describe ".all with conditions" do
+    before do
+      @user = create_user_with_2_keys
+      @api_keys = ApiKey.all(@user.id, :key_type => "application")
+    end
+    
+    it "should return an enumeration of API keys" do
+      @api_keys.each do |api_key|
+        api_key.should be_an_instance_of(ApiKey)
+      end
+    end
+    
+    it "should return correct titles" do
+      @api_keys.map(&:key_type).should == %w(application)
+    end
+  end
+
+  describe ".create" do
+    it "should create a new API key from basic params" do
+      user = create_user_with_2_keys
+      api_key = ApiKey.create(user.id, {
+        :purpose  => "Data wrangling",
+        :key_type => "valet"
+      })
+      api_key.should be_an_instance_of(ApiKey)
+      api_key.key_type.should == "valet"
+    end
+  end
+
+  describe ".first" do
+    before do
+      @user = create_user_with_2_keys
+    end
+  
+    it "should return an API key" do
+      api_key = ApiKey.first(@user.id, :purpose => "Civic hacking")
+      api_key.should be_an_instance_of(ApiKey)
+      api_key.purpose.should == "Civic hacking"
+    end
+    
+    it "should return nil if nothing found" do
+      api_key = ApiKey.first(@user.id, :purpose => "Evil")
+      api_key.should be_nil
+    end
+  end
+
+  describe ".get" do
+    before do
+      @user = create_user_with_2_keys
+      @api_key = @user.api_keys[1]
+    end
+  
+    it "should return an API key" do
+      api_key = ApiKey.get(@user.id, @api_key.id)
+      api_key.should be_an_instance_of(ApiKey)
+      api_key.purpose.should == "Civic hacking"
+    end
+    
+    it "should raise NotFound if no API key exists" do
+      executing do
+        ApiKey.get(@user.id, mangle(@api_key.id))
+      end.should raise_error(NotFound)
+    end
+  end
+
+  describe ".update" do
+    before do
+      @user = create_user_with_2_keys
+      @api_key = @user.api_keys[1]
+    end
+  
+    it "should update an existing source from valid params" do
+      api_key = ApiKey.update(@user.id, @api_key.id, {
+        :purpose => "Local Government Reporting"
+      })
+      api_key.should be_an_instance_of(ApiKey)
+      api_key.purpose.should == "Local Government Reporting"
+    end
+  end
+
+  describe ".destroy" do
+    before do
+      @user = create_user_with_2_keys
+      @api_key = @user.api_keys[1]
+    end
+  
+    it "should destroy an existing source" do
+      result = ApiKey.destroy(@user.id, @api_key.id)
+      result.should be_true
+    end
+    
+    it "should raise NotFound if API key does not exist" do
+      executing do
+        ApiKey.destroy(@user.id, mangle(@api_key.id))
+      end.should raise_error(NotFound)
+    end
+  end
+
+end

data/spec/base_spec.rb

@@ -1,184 +1,129 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe DataCatalog do
-
-  describe "module accessors" do
-
-    it "should access the API Key" do
-      DataCatalog.api_key = 'flurfeneugen'
-      DataCatalog.api_key.should == 'flurfeneugen'
-    end
-
-    it "should access the base URI" do
-      DataCatalog.base_uri = 'somehost.com'
-      DataCatalog.base_uri.should == 'somehost.com'
-    end
-  
-  end # describe "accessors"
-
-  describe ".with_key" do
-    
-    it "should set the API key within the block" do
-      DataCatalog.api_key = 'flurfeneugen'
-      temp_value = 'not_temp_key'
-      
-      DataCatalog.with_key('temp_key') do
-        temp_value = DataCatalog.api_key
-      end
-      
-      temp_value.should == 'temp_key'
-      DataCatalog.api_key.should == 'flurfeneugen'
-    end
-    
-  end # describe ".with_key"
-  
-end # describe DataCatalog
-
-describe DataCatalog::Base do
-
-  before(:each) { setup_api }
-
-  describe ".set_base_uri" do
-
-    it "should set and normalize the base URI" do
-      DataCatalog.base_uri = 'notherhost.com'
-      DataCatalog::Base.set_base_uri
-      DataCatalog::Base.default_options[:base_uri].should == 'http://notherhost.com'
-    end
-    
-    it "should set the base URI to the default if it's not explicitly defined" do
-      DataCatalog.base_uri = nil
-      DataCatalog::Base.set_base_uri
-      DataCatalog::Base.default_options[:base_uri].should == 'http://api.nationaldatacatalog.com'
-    end
-  
-  end # describe ".set_base_uri"
-  
-  describe ".set_api_key" do
-
-    it "should set the API key" do
-      DataCatalog.api_key = 'flurfeneugen'
-      DataCatalog::Base.set_api_key
-      DataCatalog::Base.default_options[:default_params].should include(:api_key => 'flurfeneugen')
-    end
-
-    it "should raise exception when attempting to set the API key but none is set" do
-      DataCatalog.api_key = nil
-      executing do
-        DataCatalog::Base.set_api_key
-      end.should raise_error(DataCatalog::ApiKeyNotConfigured)
-    end
-    
-  end # describe ".set_default_params"
-
-  describe ".set_up!" do
-    
-    it "should set both the base URI and API key" do
-      DataCatalog.base_uri = 'somehost.com'
-      DataCatalog.api_key = 'flurfeneugen'
-      DataCatalog::Base.set_up!
-      DataCatalog::Base.default_options[:base_uri].should == 'http://somehost.com'
-      DataCatalog::Base.default_options[:default_params].should include(:api_key => 'flurfeneugen')
-    end
-    
-  end # describe ".set_up!"
-  
-  describe ".build_object" do
-    
-    it "should create an object when a filled hash is passed in" do
-      base_object = DataCatalog::Base.build_object(:name => "John Smith", :email => "john@email.com")
-      base_object.should be_an_instance_of(DataCatalog::Base)
-      base_object.email.should == "john@email.com"
-    end
-    
-    it "should return nil when an empty hash is passed in" do
-      base_object = DataCatalog::Base.build_object({})
-      base_object.should be_nil
-    end
-    
-    it "should return nil when nil is passed in" do
-      base_object = DataCatalog::Base.build_object(nil)
-      base_object.should be_nil
-    end
-    
-  end # describe ".build_object!"
-
-  describe ".about" do
-
-    it "should return information about the API" do
-      base_object = DataCatalog::Base.about
-      base_object.should be_an_instance_of(DataCatalog::Base)
-      base_object.name.should == "National Data Catalog API"
-    end
-
-  end # describe ".about"
-  
-  describe ".check_status_code" do
-    
-    it "should return nil on 200 OK" do
-      response = HTTParty::Response.new(nil, '{"foo":"bar"}', 200, 'OK', {})
-      DataCatalog::Base.check_status_code(response).should be_nil
-    end
-    
-    it "should raise BadRequest on 400 Bad Request" do
-      response = HTTParty::Response.new(nil, '[]', 400, 'Bad Request', {})
-      executing do
-        DataCatalog::Base.check_status_code(response)
-      end.should raise_error(DataCatalog::BadRequest)
-    end
-
-    it "should raise Unauthorized on 401 Unauthorized" do
-      response = HTTParty::Response.new(nil, '', 401, 'Unauthorized', {})
-      executing do
-        DataCatalog::Base.check_status_code(response)
-      end.should raise_error(DataCatalog::Unauthorized)
-    end
-
-    it "should raise NotFound on 404 Not Found" do
-      response = HTTParty::Response.new(nil, '[]', 404, 'Not Found', {})
-      executing do
-        DataCatalog::Base.check_status_code(response)
-      end.should raise_error(DataCatalog::NotFound)
-    end
-    
-    it "should raise InternalServerError on 500 Internal Server Error" do
-      response = HTTParty::Response.new(nil, '', 500, 'Internal Server Error', {})
-      executing do
-        DataCatalog::Base.check_status_code(response)
-      end.should raise_error(DataCatalog::InternalServerError)
-    end
-        
-  end # describe ".check_status_code"
-  
-  describe ".error_message" do
-    
-    it "should return an 'Unable to parse:' message when body is blank" do
-      response = HTTParty::Response.new(nil, '', 404, 'Not Found', {})
-      DataCatalog::Base.error_message(response).should == %(Unable to parse: "")
-    end
-    
-    it "should return 'Response was empty' when body is an empty JSON object" do
-      response = HTTParty::Response.new(nil, '{}', 404, 'Not Found', {})
-      DataCatalog::Base.error_message(response).should == "Response was empty"
-    end
-    
-    it "should return 'Response was empty' when body is an empty array" do
-      response = HTTParty::Response.new(nil, '[]', 404, 'Not Found', {})
-      DataCatalog::Base.error_message(response).should == "Response was empty"
-    end
-    
-    it "should return the contents of the errors hash when it exists" do
-      errors = '{"errors":["bad_error"]}'
-      response = HTTParty::Response.new(nil, errors, 400, 'Bad Request', {})
-      DataCatalog::Base.error_message(response).should == '["bad_error"]'
-    end
-    
-    it "should return the contents of the response body when no errors hash exists" do
-      errors = '{"foo":["bar"]}'
-      response = HTTParty::Response.new(nil, errors, 400, 'Bad Request', {})
-      DataCatalog::Base.error_message(response).should == '{"foo":["bar"]}'
-    end
-
-  end # describe ".error_message"
-
-end # describe DataCatalog::Base
+require File.dirname(__FILE__) + '/spec_helper'
+include DataCatalog
+
+describe Base do
+
+  before do
+    setup_api
+  end
+
+  describe ".base_uri=" do
+    it "should set and normalize the base URI" do
+      setup_api
+      DataCatalog.base_uri = 'host.com'
+      DataCatalog.base_uri.should == 'http://host.com'
+    end
+    
+    it "should set the base URI to the default if it's not explicitly defined" do
+      DataCatalog.base_uri = ''
+      DataCatalog.base_uri.should == 'http://api.nationaldatacatalog.com'
+      Base.base_uri.should == 'http://api.nationaldatacatalog.com'
+    end
+  end
+
+  describe ".check_status" do
+    it "should return nil on 200 OK" do
+      response = HTTParty::Response.new(nil, '{"foo":"bar"}', 200, 'OK', {})
+      Base.check_status(response).should be_nil
+    end
+    
+    it "should raise BadRequest on 400 Bad Request" do
+      response = HTTParty::Response.new(nil, '[]', 400, 'Bad Request', {})
+      executing do
+        Base.check_status(response)
+      end.should raise_error(BadRequest)
+    end
+  
+    it "should raise Unauthorized on 401 Unauthorized" do
+      response = HTTParty::Response.new(nil, '', 401, 'Unauthorized', {})
+      executing do
+        Base.check_status(response)
+      end.should raise_error(Unauthorized)
+    end
+  
+    it "should raise NotFound on 404 Not Found" do
+      response = HTTParty::Response.new(nil, '[]', 404, 'Not Found', {})
+      executing do
+        Base.check_status(response)
+      end.should raise_error(NotFound)
+    end
+    
+    it "should raise InternalServerError on 500 Internal Server Error" do
+      response = HTTParty::Response.new(nil, '', 500, 'Internal Server Error', {})
+      executing do
+        Base.check_status(response)
+      end.should raise_error(InternalServerError)
+    end
+  end
+
+  describe ".error" do
+    it "should return an 'Unable to parse:' message when body is blank" do
+      response = HTTParty::Response.new(nil, '', 404, 'Not Found', {})
+      Base.error(response).should == %(Unable to parse: "")
+    end
+    
+    it "should return 'Response was empty' when body is an empty JSON object" do
+      response = HTTParty::Response.new(nil, '{}', 404, 'Not Found', {})
+      Base.error(response).should == "Response was empty"
+    end
+    
+    it "should return 'Response was empty' when body is an empty array" do
+      response = HTTParty::Response.new(nil, '[]', 404, 'Not Found', {})
+      Base.error(response).should == "Response was empty"
+    end
+    
+    it "should return the contents of the errors hash when it exists" do
+      errors = '{"errors":["bad_error"]}'
+      response = HTTParty::Response.new(nil, errors, 400, 'Bad Request', {})
+      Base.error(response).should == '["bad_error"]'
+    end
+    
+    it "should return the contents of the response body when no errors hash exists" do
+      errors = '{"foo":["bar"]}'
+      response = HTTParty::Response.new(nil, errors, 400, 'Bad Request', {})
+      Base.error(response).should == '{"foo":["bar"]}'
+    end
+  end
+
+  describe ".many" do
+    it "should create an object from a filled array" do
+      array = Base.many([
+        {
+          :name  => "Carl Malamud",
+          :email => "no-spam-carl@media.org"
+        },
+        {
+          :name  => "Ellen Miller",
+          :email => "no-spam-ellen@sunlightfoundation.com"
+        }
+      ])
+      array.map do |item|
+        item.should be_an_instance_of(Base)
+      end
+      array.map(&:name).should == ["Carl Malamud", "Ellen Miller"]
+    end    
+  end
+
+  describe ".one" do
+    it "should create an object from a filled hash" do
+      hash = Base.one({
+        :name  => "John Smith",
+        :email => "john@email.com"
+      })
+      hash.should be_an_instance_of(Base)
+      hash.name.should == "John Smith"
+      hash.email.should == "john@email.com"
+    end
+    
+    it "should return nil from an empty hash" do
+      hash = Base.one({})
+      hash.should be_nil
+    end
+    
+    it "should return nil from nil" do
+      hash = Base.one(nil)
+      hash.should be_nil
+    end
+  end
+
+end