communicator 0.1.0

data/lib/communicator/tasks.rb

@@ -0,0 +1,16 @@
+namespace :communicator do
+  desc "Copies all communicator gem migrations to your rails app"
+  task :update_migrations do
+    fail "Only available in Rails context!" unless defined?(Rails)
+    require 'fileutils'
+    Dir[File.join(File.dirname(__FILE__), '..', '..', 'db/migrate/*.rb')].each do |migration|
+      target = File.join(Rails.root, 'db/migrate', File.basename(migration))
+      if File.exist?(target)
+        puts "Skipped #{File.basename(migration)}, already present!"
+      else
+        FileUtils.cp(migration, target)
+        puts "Copied #{File.basename(migration)} to your Rails apps' db/migrate folder. Please do rake db:migrate"
+      end
+    end
+  end
+end

data/lib/communicator.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default)
+require 'json'
+require 'active_record'
+
+module Communicator
+  # Error to be raised when no receiver can be found for a message that is to be processed
+  class ReceiverUnknown < StandardError; end;
+  
+  # Error to be raised when no credentials were given
+  class MissingCredentials < StandardError; end;
+  
+  class << self
+    # Hash containing all receivers
+    def receivers
+      @recevers ||= {}.with_indifferent_access
+    end
+    
+    # Register a given class as a receiver from source (underscored name). Will then
+    # mix in the instance methods from Communicator::ActiveRecord::InstanceMethods so
+    # message processing and publishing functionality is included
+    def register_receiver(target, source)
+      receivers[source] = target
+      target.send(:include, Communicator::ActiveRecordIntegration::InstanceMethods)
+    end
+    
+    # Tries to find the receiver for given source, raising Communicator::ReceiverUnknown
+    # on failure
+    def receiver_for(source)
+      return receivers[source] if receivers[source]
+      raise Communicator::ReceiverUnknown.new("No receiver registered for '#{source}'")
+    end
+  end
+end
+
+require 'communicator/server'
+require 'communicator/client'
+require 'communicator/active_record_integration'
+require 'communicator/outbound_message'
+require 'communicator/inbound_message'

data/test/config.ru

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'active_record'
+require 'communicator'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => "db/test_server.sqlite3")  
+require 'lib/post'
+
+Communicator::Server.username = 'testuser'
+Communicator::Server.password = 'pwd'
+
+run Communicator::Server

data/test/factories.rb

@@ -0,0 +1,11 @@
+require 'factory_girl'
+Factory.sequence(:inbound_record_id) {|i| i}
+Factory.sequence(:outbound_record_id) {|i| i}
+
+Factory.define(:inbound_message, :class => Communicator::InboundMessage) do |f|
+  f.body { {:post => {:id => Factory.next(:inbound_record_id), :title => 'foo', :body => 'bar'}}.to_json }
+end
+
+Factory.define(:outbound_message, :class => Communicator::OutboundMessage) do |f|
+  f.body { {:post => {:id => Factory.next(:outbound_record_id), :title => 'foo', :body => 'bar'}}.to_json }
+end

data/test/helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :development)
+ENV['RACK_ENV'] = 'test'
+require 'test/unit'
+require 'rack/test'
+require 'active_record'
+require 'shoulda'
+require 'shoulda/active_record'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'communicator'
+require 'factories'
+
+# Connect to client test database
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => "db/test_client.sqlite3")
+require 'lib/post'
+
+# Connect to server database too so we can peek into what's happening over there
+class TestServerDatabase < ActiveRecord::Base
+  establish_connection(:adapter => 'sqlite3', :database => "db/test_server.sqlite3")  
+end
+require 'lib/test_server_database/post'
+require 'lib/test_server_database/inbound_message'
+require 'lib/test_server_database/outbound_message'
+
+class Test::Unit::TestCase
+  def setup
+    # Reset communicator credentials every time
+    Communicator::Client.username = nil
+    Communicator::Client.password = nil
+    Communicator::Client.base_uri nil
+    
+    Communicator::Server.username = nil
+    Communicator::Server.password = nil
+    
+    # Purge the databases every time...
+    Communicator::InboundMessage.delete_all
+    Communicator::OutboundMessage.delete_all
+    Post.delete_all
+    
+    TestServerDatabase::InboundMessage.delete_all
+    TestServerDatabase::OutboundMessage.delete_all
+    TestServerDatabase::Post.delete_all
+  end
+end

data/test/lib/post.rb

@@ -0,0 +1,7 @@
+# A simple class for publishing and receiving messages
+class Post < ActiveRecord::Base
+  receives_from :post
+  after_save do |p|
+    p.publish unless p.updated_from_message
+  end
+end

data/test/lib/test_server_database/inbound_message.rb

@@ -0,0 +1,4 @@
+# Basic class for introspection of what is happening on the server side
+class TestServerDatabase::InboundMessage < TestServerDatabase
+  set_table_name "inbound_messages"
+end

data/test/lib/test_server_database/outbound_message.rb

@@ -0,0 +1,4 @@
+# Basic class for introspection of what is happening on the server side
+class TestServerDatabase::OutboundMessage < TestServerDatabase
+  set_table_name "outbound_messages"
+end

data/test/lib/test_server_database/post.rb

@@ -0,0 +1,4 @@
+# Basic class for introspection of what is happening on the server side
+class TestServerDatabase::Post < TestServerDatabase
+  set_table_name "posts"
+end

data/test/migrate/20101101093519_create_posts.rb

@@ -0,0 +1,13 @@
+class CreatePosts < ActiveRecord::Migration
+  def self.up
+    create_table :posts do |t|
+      t.string   :title, :null => false
+      t.text     :body, :null => false
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :posts
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,146 @@
+require 'helper'
+
+#
+# Unit tests for client and it's interaction with the real server running in background
+# on port 20359. For introspection purposes, a simple second database connection
+# has been established as TestServerDatabase
+#
+class TestClient < Test::Unit::TestCase
+  context "Without auth credentials configured" do
+    context "PUSH" do
+      should "raise an exception" do
+        assert_raise Communicator::MissingCredentials do 
+          Communicator::Client.push
+        end
+      end
+    end
+    
+    context "PULL" do
+      should "raise an exception" do
+        assert_raise Communicator::MissingCredentials do 
+          Communicator::Client.pull
+        end
+      end
+    end
+  end
+  
+  context "with server configured" do
+    setup do
+      Communicator::Client.username = 'testuser'
+      Communicator::Client.password = 'pwd'
+      Communicator::Client.base_uri 'localhost:20359'
+    end
+    
+    context "PUSH" do
+      setup { Communicator::Client.push }
+      
+      should "not have any inbound messages in server" do
+        assert_equal 0, TestServerDatabase::InboundMessage.count
+      end
+    end
+    
+    context "PULL" do
+      setup { Communicator::Client.pull }
+      
+      should "not have any inbound messages locally" do
+        assert_equal 0, Communicator::InboundMessage.count
+      end
+    end
+    
+    context "after creating a local Post" do
+      setup do
+        @post = Post.create!(:title => 'foo', :body => 'local post')
+      end
+      
+      should "have created an outbound message locally" do
+        assert_equal 'local post', Communicator::OutboundMessage.first.message_content["post"]["body"]
+        assert_nil Communicator::OutboundMessage.first.delivered_at
+      end
+      
+      context "after PUSH" do
+        setup { Communicator::Client.push }
+        
+        should "have flagged the outbound message as delivered" do
+          assert_equal 0, Communicator::OutboundMessage.undelivered.count
+        end
+        
+        should "have created the corresponding inbound message at remote" do
+          assert_equal 1, TestServerDatabase::InboundMessage.count
+          assert msg = TestServerDatabase::InboundMessage.first
+          assert_equal 'local post', JSON.parse(msg.body)["post"]["body"]
+          assert_equal 'foo', JSON.parse(msg.body)["post"]["title"]
+          assert msg.processed_at > 3.seconds.ago
+        end
+        
+        should "have created the corresponding Post at remote" do
+          assert_equal 1, TestServerDatabase::Post.count
+          assert post = TestServerDatabase::Post.first
+          assert_equal 'local post', post.body
+          assert_equal 'foo', post.title
+        end
+        
+        should "not have created outbound message at remote" do
+          assert_equal 0, TestServerDatabase::OutboundMessage.count
+        end
+        
+        context "when i try to PUSH the same message again" do
+          setup do
+            @post.title = 'changed'
+            Communicator::OutboundMessage.first.update_attribute(:body, @post.to_json)
+            Communicator::OutboundMessage.first.update_attribute(:delivered_at, nil)
+            Communicator::Client.push
+          end
+          
+          should "not have updated the remote message" do
+            assert_equal 1, TestServerDatabase::InboundMessage.count
+            assert_equal 'foo', JSON.parse(TestServerDatabase::InboundMessage.first.body)["post"]["title"]
+          end
+        end
+        
+        context "when an update message is created at remote" do
+          setup do
+            @remote_msg = TestServerDatabase::OutboundMessage.create!(:body => {:post => {:id => @post.id, :title => 'new title', :body => 'remote body'}}.to_json)
+          end
+          
+          context "a PULL" do
+            setup do
+              Communicator::Client.pull
+            end
+            
+            should "result in the local post getting updated" do
+              @post.reload
+              assert_equal 'new title', @post.title
+              assert_equal 'remote body', @post.body
+            end
+            
+            should "have created the corresponding inbound message" do
+              assert_equal 1, Communicator::InboundMessage.count
+            end
+          end
+        end
+      end
+    end
+    
+    context "when an update message is created at remote" do
+      setup do
+        @remote_msg = TestServerDatabase::OutboundMessage.create!(:body => {:post => {:id => 25, :title => 'new title', :body => 'remote body'}}.to_json)
+      end
+      
+      context "a PULL" do
+        setup do
+          Communicator::Client.pull
+        end
+        
+        should "result in a local post getting created" do
+          post = Post.find(25)
+          assert_equal 'new title', post.title
+          assert_equal 'remote body', post.body
+        end
+        
+        should "have created the corresponding inbound message" do
+          assert_equal 1, Communicator::InboundMessage.count
+        end
+      end
+    end
+  end
+end

data/test/test_message_models.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+class TestMessageModels < Test::Unit::TestCase
+  context "A new inbound message" do
+    subject { Communicator::InboundMessage.new }
+    should_validate_presence_of :body
+  end
+  
+  context "A new outbound message" do
+    subject { Communicator::OutboundMessage.new }
+    should_validate_presence_of :body
+  end
+  
+  context "With a couple inbound messages existing" do
+    setup { 5.times { Factory.create(:inbound_message) } }
+    
+    should "return an appropriate last_id" do
+      assert_equal Communicator::InboundMessage.last_id, Communicator::InboundMessage.all.map(&:id).sort.last
+    end
+  end
+  
+  context "A inbound message for a post that does not exist locally yet" do
+    setup do
+      @message = Factory.create(:inbound_message)
+      @post = ::Post.find(JSON.parse(@message.body)["post"]["id"])
+    end
+    
+    should "have all attributes of the post matching those in the json body" do
+      JSON.parse(@message.body)["post"].each do |attr_name, value|
+        assert_equal @post.send(attr_name), value
+      end
+    end
+    
+    context "after another Inbound Message for the same Post" do
+      setup do
+        @message = Factory.create(:inbound_message, :body => {
+          :post => { :id => @post.id, 
+                     :title => 'new title', 
+                     :body => 'new malarkey'} }.to_json)
+        @post.reload
+      end
+      
+      should "have updated the posts title and body" do
+        assert_equal @post.title, 'new title'
+        assert_equal @post.body,  'new malarkey'
+      end
+      
+      should "not have created any Outbound messages" do
+        assert_equal 0, Communicator::OutboundMessage.count
+      end
+      
+      context "after an update to the post" do
+        setup do
+          @post.title = 'changed locally'
+          @post.save!
+        end
+        
+        should "Have created an outbound message" do
+          assert_equal 1, Communicator::OutboundMessage.count
+        end
+        
+        should "have an outbound message with correct title" do
+          assert_equal 'changed locally', JSON.parse(Communicator::OutboundMessage.first.body)["post"]["title"]
+        end
+      end
+    end
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,133 @@
+require 'helper'
+require 'base64'
+
+# Unit tests for the server component using rack test in isolation
+# Please note that this is using the CLIENT database, since we are testing locally
+# as opposed to the tests of client/server interaction, which use the Client and Server
+# DB
+#
+class TestServer < Test::Unit::TestCase
+  include Rack::Test::Methods
+  
+  def app
+    Communicator::Server.username = 'someguy'
+    Communicator::Server.password = 'password'
+    Communicator::Server
+  end
+
+  context "Unauthorized" do
+    context "GET /messages.json" do
+      setup { get '/messages.json' }
+      should("return forbidden status") { assert_equal 401, last_response.status}
+    end
+    
+    context "POST /messages.json" do
+      setup { post '/messages.json' } 
+      should("return forbidden status") { assert_equal 401, last_response.status}
+    end
+  end
+  
+  context "Authorized" do
+    context "GET /messages.json" do
+      context "without from_id" do
+        setup { get '/messages.json', {}, auth_header('someguy', 'password') }
+        should("return rejected status") { assert_equal 409, last_response.status}
+      end
+      
+      context "with from_id" do
+        setup { get '/messages.json', {:from_id => 1}, auth_header('someguy', 'password') }
+        should("return success status") { assert_equal 200, last_response.status }
+        should("return empty json array") { assert_equal "[]", last_response.body }
+      end
+      
+      context "with existing OutboundMessages" do
+        setup { 5.times { Factory.create(:outbound_message) } }
+        
+        should "have 5 items in undelivered named_scope" do
+          assert_equal 5, Communicator::OutboundMessage.undelivered.count
+        end
+        
+        context "and proper from_id" do
+          setup do
+            get '/messages.json', {:from_id => 1}, auth_header('someguy', 'password')
+            @json = JSON.parse(last_response.body)
+          end
+        
+          should "have rendered successfully" do
+            assert_equal 200, last_response.status
+          end
+        
+          should "have returned 5 messages" do
+            assert_equal 5, @json.length
+          end
+        
+          should "have proper representations of all messages" do
+            @json.each do |json|
+              message = Communicator::OutboundMessage.find(json["id"])
+              assert_equal message.body, json["body"]
+            end
+          end
+        
+          should "have flagged all outbound messages as delivered" do
+            Communicator::OutboundMessage.all.each do |msg|
+              assert msg.delivered_at > 5.seconds.ago
+            end
+          end
+        
+          should "have no outbound in undelivered named_scope" do
+            assert_equal 0, Communicator::OutboundMessage.undelivered.count
+          end
+        
+          context "another GET with updated from_id" do
+            setup do
+              get '/messages.json', {:from_id => Communicator::OutboundMessage.first(:order => 'id DESC').id+1}, auth_header('someguy', 'password')
+            end
+          
+            should "have rendered empty json array" do
+              assert_equal "[]", last_response.body
+            end
+          end
+        end
+      end
+    end
+    
+    context "POST /messages.json" do
+      context "without body" do
+        setup { post '/messages.json', {}, auth_header('someguy', 'password') } 
+        should("return rejected status") { assert_equal 409, last_response.status}
+      end
+      
+      context "with empty array in body" do
+        setup { post '/messages.json', "[]", auth_header('someguy', 'password') } 
+        should("return accepted status") { assert_equal 202, last_response.status}
+      end
+      
+      context "with 1 post in body" do
+        setup do
+          assert Communicator::InboundMessage.count == 0, "Should have no inbound"
+          post '/messages.json', [{:id => 1, :body => {:post => {:id => 1, :title => 'foo', :body => 'bar'}}.to_json}].to_json, auth_header('someguy', 'password')
+        end
+        should("return accepted status") { assert_equal 202, last_response.status }
+        should "have created the inbound message" do
+          assert_equal 1, Communicator::InboundMessage.count
+        end
+        should "have created the corresponding post" do
+          assert post = Post.find(1)
+          assert_equal 'foo', post.title
+          assert_equal 'bar', post.body
+        end
+      end
+    end
+  end
+  
+  private
+  
+  def auth_header(username, password)
+    {'HTTP_AUTHORIZATION' => encode_credentials(username, password)}
+  end
+
+  def encode_credentials(username, password)
+    "Basic " + Base64.encode64("#{username}:#{password}")
+  end
+
+end