keikokuc 0.7 → 0.8

data/lib/keikokuc/client.rb

@@ -11,12 +11,16 @@ class Keikokuc::Client
   InvalidNotification = Class.new
   Unauthorized = Class.new
 
-  attr_accessor :producer_api_key, :user, :password
+  attr_accessor :username, :api_key
 
+  # Internal: Initialize a Client
+  #
+  # opts = a hash containing two possible attributes:
+  #   api_key - the user's or producer's API key (required)
+  #   username - the producer's username (only required for publishers)
   def initialize(opts = {})
-    @producer_api_key = opts[:producer_api_key]
-    @user             = opts[:user]
-    @password         = opts[:password]
+    @api_key  = opts.fetch(:api_key)
+    @username = opts[:username]
   end
 
   # Internal: posts a new notification to keikoku
@@ -25,7 +29,8 @@ class Keikokuc::Client
   #
   # Examples
   #
-  #   client = Keikokuc::Client.new(producer_api_key: 'abcd')
+  #   client = Keikokuc::Client.new(username: 'heroku-postgres',
+  #                                  api_key: 'abcd')
   #   response, error = client.post_notification(message: 'hello')
   #
   # Returns
@@ -42,7 +47,7 @@ class Keikokuc::Client
   # * `Client::Unauthorized` if API key auth fails
   def post_notification(attributes)
     begin
-      response = notifications_api.post(encode_json(attributes), {'X-KEIKOKU-AUTH' => producer_api_key})
+      response = notifications_api.post(encode_json(attributes))
       [parse_json(response), nil]
     rescue RestClient::UnprocessableEntity => e
       [parse_json(e.response), InvalidNotification]
@@ -56,7 +61,7 @@ class Keikokuc::Client
   #
   # Examples
   #
-  #   client = Keikokuc::Client.new(user: 'user@example.com', password: 'pass')
+  #   client = Keikokuc::Client.new(api_key: 'api-key')
   #   response, error = client.get_notifications
   #
   # Returns
@@ -83,6 +88,8 @@ class Keikokuc::Client
   #
   # remote_id - the keikoku id for the notification to mark as read
   #
+  # Returns
+  #
   # two objects:
   #   The response as a hash
   #   The error if any (nil if no error)
@@ -95,7 +102,6 @@ class Keikokuc::Client
     begin
       response = notifications_api["/#{remote_id}/read"].post ''
       parsed_response = parse_json(response)
-      parsed_response[:read_at] = DateTime.parse(parsed_response[:read_at])
       [parsed_response, nil]
     rescue RestClient::Unauthorized
       [{}, Unauthorized]
@@ -103,12 +109,13 @@ class Keikokuc::Client
   end
   handle_timeout :read_notification
 
-
 private
   def notifications_api # :nodoc:
-    @notifications_api ||= RestClient::Resource.new(api_url,
-                                                    :user     => user,
-                                                    :password => password)
+    @notifications_api ||= RestClient::Resource.new(
+      api_url,
+      :user     => username || '',
+      :password => api_key
+    )
   end
 
   def api_url # :nodoc:

data/lib/keikokuc/notification.rb

@@ -7,7 +7,8 @@
 #   notification = Keikokuc::Notification.new(message: 'hello',
 #                                             severity: 'info',
 #                                             target_name: 'sunny-skies-42'
-#                                             producer_api_key: 'abcd')
+#                                             producer_password: 'abcd',
+#                                             username: 'heroku-postgres')
 #   if notification.publish
 #     # persist notification
 #   else
@@ -17,8 +18,8 @@
 class Keikokuc::Notification
   attr_accessor :message, :url, :severity,
                 :target_name, :account_email,
-                :producer_api_key, :remote_id,
-                :errors, :read_at, :account_sequence
+                :producer_password, :username,
+                :remote_id, :errors, :account_sequence
 
   # Public: Initialize a notification
   #
@@ -30,17 +31,17 @@ class Keikokuc::Notification
   #
   # All keys on the attr_accessor list will be set
   def initialize(opts = {})
-    @message          = opts[:message]
-    @url              = opts[:url]
-    @severity         = opts[:severity]
-    @target_name      = opts[:target_name]
-    @account_email    = opts[:account_email]
-    @producer_api_key = opts[:producer_api_key]
-    @remote_id        = opts[:remote_id]
-    @errors           = opts[:errors]
-    @read_at          = opts[:read_at]
-    @account_sequence = opts[:account_sequence]
-    @client           = opts[:client]
+    @message           = opts[:message]
+    @url               = opts[:url]
+    @severity          = opts[:severity]
+    @target_name       = opts[:target_name]
+    @account_email     = opts[:account_email]
+    @producer_password = opts[:producer_password]
+    @username          = opts[:username]
+    @remote_id         = opts[:remote_id]
+    @errors            = opts[:errors]
+    @account_sequence  = opts[:account_sequence]
+    @client            = opts[:client]
   end
 
   # Public: publishes this notification to keikoku
@@ -70,39 +71,31 @@ class Keikokuc::Notification
   # Returns a boolean set to true if marking as read succeeded
   def read
     response, error = client.read_notification(remote_id)
-    if error.nil?
-      self.read_at = response[:read_at]
-    end
     error.nil?
   end
 
-  # Public: whether this notification is marked as read by this user
-  #
-  # Returns true if the user has marked this notification as read
-  def read?
-    !!@read_at
-  end
-
   # Internal: coerces this notification to a hash
   #
   # Returns this notification's attributes as a hash
   def to_hash
     {
-      :message          => @message,
-      :url              => @url,
-      :severity         => @severity,
-      :target_name      => @target_name,
-      :account_email    => @account_email,
-      :producer_api_key => @producer_api_key,
-      :remote_id        => @remote_id,
-      :errors           => @errors,
-      :read_at          => @read_at,
-      :account_sequence => @account_sequence,
-      :client           => @client
+      :message           => @message,
+      :url               => @url,
+      :severity          => @severity,
+      :target_name       => @target_name,
+      :account_email     => @account_email,
+      :producer_password => @producer_password,
+      :remote_id         => @remote_id,
+      :errors            => @errors,
+      :account_sequence  => @account_sequence,
+      :client            => @client
     }
   end
 
   def client # :nodoc:
-    @client ||= Keikokuc::Client.new(:producer_api_key => producer_api_key)
+    @client ||= Keikokuc::Client.new(
+      :username => username,
+      :api_key  => producer_password
+    )
   end
 end

data/lib/keikokuc/notification_list.rb

@@ -8,8 +8,7 @@
 #
 # Examples
 #
-#   notifications = Keikokuc::NotificationList.new(user:    'user@example.com',
-#                                                  api_key: 'abcd')
+#   notifications = Keikokuc::NotificationList.new(api_key: 'abcd')
 #   if notifications.fetch
 #     notifications.each do |notification|
 #       puts notification.inspect
@@ -20,18 +19,16 @@
 class Keikokuc::NotificationList
   include Enumerable
 
-  attr_accessor :user, :password
+  attr_accessor :api_key
 
   # Public: Initializes a NotificationList
   #
   # opts - options hash containing attribute values for the object
   #        being constructed accepting the following three keys:
-  #  user - the heroku account's email (required)
-  #  password - the heroku account's password (required)
+  #  api_key - the heroku account's api_key (required)
   #  client - the client, used for DI in tests
   def initialize(opts)
-    @user          = opts.fetch(:user)
-    @password      = opts.fetch(:password)
+    @api_key       = opts.fetch(:api_key)
     @client        = opts[:client]
     @notifications = []
   end
@@ -95,7 +92,7 @@ class Keikokuc::NotificationList
 
 private
   def client # :nodoc:
-    @client ||= Keikokuc::Client.new(:user     => user,
-                                     :password => password)
+    @client ||= Keikokuc::Client.new(:user    => '',
+                                     :api_key => api_key)
   end
 end

data/lib/keikokuc/version.rb

@@ -1,3 +1,3 @@
 module Keikokuc
-  VERSION = "0.7"
+  VERSION = "0.8"
 end

data/spec/keikoku/client_spec.rb

@@ -11,8 +11,8 @@ module Keikokuc
 
     it 'publishes a new notification' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_publisher({:api_key => 'abc'})
-      client = Client.new(:producer_api_key => 'abc')
+      fake_keikoku.register_producer({:api_key => 'abc', :username => 'heroku-postgres'})
+      client = Client.new(:api_key => 'abc', :username => 'heroku-postgres')
       result, error = client.post_notification(:message  => 'hello',
                                                :severity => 'info')
       expect(result[:id]).not_to be_nil
@@ -24,15 +24,15 @@ module Keikokuc
         [422, {}, StringIO.new(OkJson.encode({ 'errors' => 'srorre' }))]
       end
 
-      response, error = Client.new.post_notification({})
+      response, error = Client.new(:api_key => 'key').post_notification({})
       expect(error).to be Client::InvalidNotification
       expect(response[:errors]).to eq('srorre')
     end
 
     it 'handles authentication failures' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_publisher({:api_key => 'abc'})
-      client = Client.new(:producer_api_key => 'bad one')
+      fake_keikoku.register_producer({:api_key => 'abc', :username => 'heroku-postgres'})
+      client = Client.new(:api_key => 'bad one', :username => 'heroku-postgres')
       result, error = client.post_notification(:message  => 'hello',
                                                :severity => 'info')
       expect(result[:id]).to be_nil
@@ -41,7 +41,7 @@ module Keikokuc
 
     it 'handles timeouts' do
       RestClient::Resource.any_instance.stub(:post).and_raise Timeout::Error
-      response, error = Client.new.post_notification({})
+      response, error = Client.new(:api_key => 'key').post_notification({})
       expect(response).to be_nil
       expect(error).to eq(Client::RequestTimeout)
     end
@@ -52,12 +52,14 @@ module Keikokuc
 
     it 'gets all notifications for a user' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_publisher(:api_key => 'abc')
-      fake_keikoku.register_user(:email => 'harold@heroku.com', :password => 'pass')
-      build_notification(:account_email => 'harold@heroku.com', :message => 'find me!', :producer_api_key => 'abc').publish
-      build_notification(:account_email => 'another@heroku.com', :producer_api_key => 'abc').publish
+      fake_keikoku.register_producer(:username => 'heroku-postgres', :api_key => 'abc')
+      fake_keikoku.register_user(:api_key => 'api-key', :account_email => 'harold@heroku.com')
+      build_notification(:account_email => 'harold@heroku.com', :message => 'find me!',
+                         :producer_password => 'abc', :username => 'heroku-postgres').publish
+      build_notification(:account_email => 'another@heroku.com', :producer_password => 'abc',
+                         :username => 'heroku-postgres').publish
 
-      client = Client.new(:user => 'harold@heroku.com', :password => 'pass')
+      client = Client.new(:api_key => 'api-key')
 
       notifications, error = client.get_notifications
 
@@ -69,15 +71,15 @@ module Keikokuc
 
     it 'handles timeouts' do
       RestClient::Resource.any_instance.stub(:get).and_raise Timeout::Error
-      response, error = Client.new.get_notifications
+      response, error = Client.new(:api_key => 'key').get_notifications
       expect(response).to be_nil
       expect(error).to eq(Client::RequestTimeout)
     end
 
     it 'handles authentication failures' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_user(:email => 'harold@heroku.com', :password => 'pass')
-      client = Client.new(:user => 'harold@heroku.com', :password => 'bad-pass')
+      fake_keikoku.register_user(:api_key => 'api-key', :account_email => 'harold@heroku.com')
+      client = Client.new(:api_key => 'bad-api-key')
 
       response, error = client.get_notifications
 
@@ -88,28 +90,28 @@ module Keikokuc
 
   describe Client, '#read_notification' do
     include_context 'client specs'
+
     it 'marks the notification as read' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_publisher(:api_key => 'abc')
-      fake_keikoku.register_user(:email => 'harold@heroku.com', :password => 'pass')
-      client = Client.new(:user => 'harold@heroku.com', :password => 'pass')
-      notification = build_notification(:account_email    => 'harold@heroku.com',
-                                        :producer_api_key => 'abc')
+
+      fake_keikoku.register_producer(:username => 'heroku-postgres', :api_key => 'abc')
+      fake_keikoku.register_user(:api_key => 'api-key', :account_email => 'harold@heroku.com')
+      client = Client.new(:api_key => 'api-key')
+      notification = build_notification(:account_email     => 'harold@heroku.com',
+                                        :producer_password  => 'abc',
+                                        :username => 'heroku-postgres')
       notification.publish or raise "Notification publish error"
 
       response, error = client.read_notification(notification.remote_id)
       expect(error).to be_nil
 
-      expect(response[:read_by]).to eq('harold@heroku.com')
-      expect(response[:read_at]).to be_within(1).of(DateTime.now)
+      expect(response[:status]).to eq('ok')
     end
 
     it 'handles authentication errors' do
       ShamRack.mount(fake_keikoku, "keikoku.herokuapp.com", 443)
-      fake_keikoku.register_user(:email    => 'harold@heroku.com',
-                                 :password => 'pass')
-      client = Client.new(:user     => 'harold@heroku.com',
-                          :password => 'bad-pass')
+      fake_keikoku.register_user(:api_key => 'api-key', :account_email => 'harold@heroku.com')
+      client = Client.new(:api_key => 'bad-api-key')
       response, error = client.read_notification(1)
       expect(response).to be_empty
       expect(error).to eq(Client::Unauthorized)
@@ -117,7 +119,7 @@ module Keikokuc
 
     it 'handles timeouts' do
       RestClient::Resource.any_instance.stub(:post).and_raise Timeout::Error
-      response, error = Client.new.read_notification(1)
+      response, error = Client.new(:api_key => 'key').read_notification(1)
       expect(response).to be_nil
       expect(error).to eq(Client::RequestTimeout)
     end

data/spec/keikoku/notification_list_spec.rb

@@ -65,11 +65,6 @@ module Keikokuc
       list.fetch or raise "error fetching"
 
       expect(list.read_all).to be_true
-
-      list.each do |notification|
-        expect(notification).to be_read
-        expect(notification.read_at).to eq(now)
-      end
     end
 
     it 'returns false if any notification fails to be marked as read' do

data/spec/keikoku/notification_spec.rb

@@ -51,15 +51,12 @@ module Keikokuc
 
       fake_client.should_receive(:read_notification).
         with('1234').
-        and_return([{:read_at => Time.now}, nil])
+        and_return([{'status' => 'ok'}, nil])
 
       notification = Notification.new(:remote_id => '1234', :client => fake_client)
 
       result = notification.read
       expect(result).to be_true
-
-      expect(notification.read_at).to be_within(1).of(Time.now)
-      expect(notification).to be_read
     end
 
     it 'handles errors' do
@@ -73,28 +70,15 @@ module Keikokuc
 
       result = notification.read
       expect(result).to be_false
-
-      expect(notification.read_at).to be_nil
-      expect(notification).not_to be_read
-    end
-  end
-
-  describe Notification, '#read?' do
-    it 'is true if the read_at is known' do
-      notification = build_notification(:read_at => nil)
-      expect(notification.read?).to be_false
-
-      notification.read_at = Time.now
-
-      expect(notification.read?).to be_true
     end
   end
 
   describe Notification, '#client' do
     it 'defaults to a properly constructer Keikokuc::Client' do
-      notification = build_notification(:producer_api_key => 'fake-api-key')
+      notification = build_notification(:producer_password => 'fake-api-key', :username => 'heroku-postgres')
       expect(notification.client).to be_kind_of(Keikokuc::Client)
-      expect(notification.client.producer_api_key).to eq('fake-api-key')
+      expect(notification.client.api_key).to eq('fake-api-key')
+      expect(notification.client.username).to eq('heroku-postgres')
     end
 
     it 'can be injected' do

data/spec/support/factories.rb

@@ -11,8 +11,7 @@ module Factories
 
   def build_notification_list(opts = {})
     defaults = {
-      :user     => 'user@example.com',
-      :password => 'pass'
+      :api_key => 'api-key'
     }
     Keikokuc::NotificationList.new(defaults.merge(opts))
   end

data/spec/support/fake_keikoku.rb

@@ -1,24 +1,28 @@
 class FakeKeikoku
   def initialize
-    @publishers = []
+    @producers = []
     @notifications = []
     @users = []
   end
 
-  def register_publisher(opts)
-    @publishers << opts
+  def register_producer(opts)
+    @producers << opts
   end
 
   def register_user(opts)
     @users << opts
   end
 
-  def publisher_by_api_key(api_key)
-    @publishers.detect { |p| p[:api_key] == api_key }
+  def producer_by_api_key(api_key)
+    @producers.detect { |p| p[:api_key] == api_key }
   end
 
-  def find_user(user, pass)
-    @users.detect { |u| u[:email] == user && u[:password] == pass }
+  def find_user(api_key)
+    @users.detect { |u| u[:api_key] == api_key }
+  end
+
+  def find_producer(user, api_key)
+    @producers.detect { |p| p[:username] == user && p[:api_key] == api_key }
   end
 
   def notifications_for_user(email)
@@ -30,7 +34,7 @@ class FakeKeikoku
   def call(env)
     with_rack_env(env) do
       if request_path == '/api/v1/notifications' && request_verb == 'POST'
-        if publisher_by_api_key(request_api_key)
+        if authenticate_producer
           notification = Notification.new({:id => next_id}.merge(request_body))
           @notifications << notification
           [200, { }, [Keikokuc::OkJson.encode({'id' => notification.id})]]
@@ -38,8 +42,8 @@ class FakeKeikoku
           [401, { }, ["Not authorized"]]
         end
       elsif request_path == '/api/v1/notifications' && request_verb == 'GET'
-        if current_user = authenticate_consumer
-          notifications = notifications_for_user(current_user).map(&:to_hash)
+        if api_key = authenticate_consumer
+          notifications = notifications_for_user(api_key).map(&:to_hash)
           [200, { }, [Keikokuc::OkJson.encode(notifications)]]
         else
           [401, { }, ["Not authorized"]]
@@ -50,7 +54,7 @@ class FakeKeikoku
             notification.to_hash['id'].to_s == $1.to_s
           end
           notification.mark_read_by!(current_user)
-          [200, {}, [Keikokuc::OkJson.encode({'read_by' => current_user, 'read_at' => Time.now.to_s})]]
+          [200, {}, [Keikokuc::OkJson.encode({'status' => 'ok'})]]
         else
           [401, { }, ["Not authorized"]]
         end
@@ -85,16 +89,21 @@ private
     Keikokuc::OkJson.decode(raw_body)
   end
 
-  def request_api_key
-    rack_env["HTTP_X_KEIKOKU_AUTH"]
+  def authenticate_producer
+    auth = Rack::Auth::Basic::Request.new(rack_env)
+    if auth.provided? && auth.basic? && creds = auth.credentials
+      if find_producer(*creds)
+        creds.first
+      end
+    end
   end
 
   def authenticate_consumer
     auth = Rack::Auth::Basic::Request.new(rack_env)
     if auth.provided? && auth.basic? && creds = auth.credentials
-      # creds looks like [user, password]
-      if find_user(*creds)
-        creds.first
+      # creds looks like [user, password] (technically ['', api_key])
+      if user = find_user(creds[-1])
+        user[:account_email]
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keikokuc
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-20 00:00:00.000000000 Z
+date: 2013-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70175173062000 !ruby/object:Gem::Requirement
+  requirement: &70304476052160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70175173062000
+  version_requirements: *70304476052160
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70175173061580 !ruby/object:Gem::Requirement
+  requirement: &70304475972260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70175173061580
+  version_requirements: *70304475972260
 - !ruby/object:Gem::Dependency
   name: sham_rack
-  requirement: &70175173061160 !ruby/object:Gem::Requirement
+  requirement: &70304475971620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70175173061160
+  version_requirements: *70304475971620
 description: Keikoku client
 email:
 - harold.gimenez@gmail.com
@@ -104,3 +104,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/factories.rb
 - spec/support/fake_keikoku.rb
+has_rdoc: