converse 1.0.25 → 1.0.26

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+.idea
 .bundle
 .config
 .yardoc

data/.idea/converse.iml

@@ -5,6 +5,13 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" scope="PROVIDED" name="bundler (v1.1.5, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="diff-lcs (v1.1.3, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="json (v1.7.5, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="mysql2 (v0.3.12b2, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec (v2.12.0, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-core (v2.12.0, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-expectations (v2.12.0, RVM: ruby-1.9.3-p194) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-mocks (v2.12.0, RVM: ruby-1.9.3-p194) [gem]" level="application" />
   </component>
 </module>
 

data/README.md

@@ -24,6 +24,11 @@ the provider. The application specifies its API through a set of methods that as
 
 Brokers can be chained for multiple translation / technology bridging.
 
+Brokers and conversations supplied with the gem: HTML, REST, MySQL
+Brokers and conversations planned for future release: MCollective, Redis, ActiveMQ
+
+This gem is sponsored by Hetzner (Pty) Ltd - http://hetzner.co.za
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -1,2 +1,7 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/converse.gemspec

@@ -14,4 +14,8 @@ Gem::Specification.new do |gem|
   gem.name          = "converse"
   gem.require_paths = ["lib"]
   gem.version       = Converse::VERSION
+
+  gem.add_dependency "json"
+  gem.add_dependency "mysql2"
+  gem.add_development_dependency "rspec"
 end

data/lib/converse.rb

@@ -8,5 +8,4 @@ require "converse/comms/mysql/mysql_conversation.rb"
 require "converse/comms/simple_logger.rb"
 
 module Converse
-  # Your code goes here...
 end

data/lib/converse/comms/html/html_conversation.rb

@@ -1,6 +1,5 @@
 require 'net/http'
 require "converse/comms/conversation"
-require "json"
 
 module Converse
   class HTMLConversation < Conversation

data/lib/converse/rest/rest_interaction.rb

@@ -1,5 +1,6 @@
 require 'cgi'
 require "converse/interaction"
+require "json"
 
 module Converse
   class RESTInteraction < Interaction
@@ -55,7 +56,8 @@ module Converse
     def is_json
       begin
         JSON.parse(@validation)
-      rescue TypeError
+        true
+      rescue ::Exception
         raise ArgumentError, "#{@validation} is not in JSON format"
       end
     end

data/lib/converse/version.rb

@@ -1,3 +1,3 @@
 module Converse
-  VERSION = "1.0.25"
+  VERSION = "1.0.26"
 end

data/spec/converse/api_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "api"
+
+module Converse
+  describe API do
+    context "when constructed with a broker" do
+      it "should remember the broker" do
+        @broker = "broker"
+        @iut = API.new(@broker)
+        @iut.broker.should == @broker
+      end
+    end
+  end
+end

data/spec/converse/broker_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "broker"
+
+module Converse
+  describe Broker do
+    before :each do
+      @iut = Broker.new
+    end
+
+    context "when constructed" do
+      it "should facilitate memory of a domain language indicator" do
+        @iut.domain_language = "hosting"
+        @iut.domain_language.should == "hosting"
+      end
+    end
+
+    context "serving as an abstract base class" do
+      it "should do have a method open_topic that takes concern and action and does nothing" do
+        result = @iut.open_topic("concern", "action")
+        result.nil?.should == true
+      end
+
+      it "should do have a method broker_conversation that takes a topic and does nothing" do
+        result = @iut.broker_conversation("topic")
+        result.nil?.should == true
+      end
+
+      it "should do have a method translate_response that takes a response and transparently returns it" do
+        result = @iut.translate_response("response")
+        result.should == "response"
+      end
+    end
+
+    context "when facilitating a discussion" do
+      it "should open the topic and broker the conversation" do
+        class BrokerInterceptor < Broker
+          attr_accessor :topic_opened
+          attr_accessor :conversation_brokered
+
+          def open_topic(concern, action)
+            @topic_opened = true
+          end
+
+          def broker_conversation(topic)
+            @conversation_brokered = true
+          end
+        end
+
+        @iut = BrokerInterceptor.new
+        @iut.discuss("concern", "action")
+        @iut.topic_opened.should == true
+        @iut.conversation_brokered.should == true
+      end
+    end
+  end
+end

data/spec/converse/comms/conversation_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "comms/conversation"
+
+module Converse
+  describe Conversation do
+    class TestSubscriber
+      attr_accessor :data
+
+      def notify(message)
+         @data = message
+      end
+    end
+
+    before :each do
+      @iut = Conversation.new("http://somewhere.com:8081/something?parama=valuea")
+    end
+
+    context "when constructed with a URI" do
+      it "should remember the URI and extract the host, port and path from the URI" do
+        @iut.uri.should == "http://somewhere.com:8081/something?parama=valuea"
+        @iut.host.should == "somewhere.com"
+        @iut.port.should == 8081
+        @iut.path.should == "/something"
+      end
+
+      it "should have no subscribers" do
+        @iut.subscribers.size.should == 0
+      end
+    end
+
+    context "as an abstract base class" do
+      it "should raise an error on ask" do
+        expect {@iut.ask}.to raise_error NotImplementedError
+      end
+
+      it "should raise an error on say" do
+        expect {@iut.say}.to raise_error NotImplementedError
+      end
+    end
+
+    context "when managing subscribers" do
+      it "should append the subscriber to the list of subscribers" do
+        @iut.subscribe(TestSubscriber.new)
+        @iut.subscribe(TestSubscriber.new)
+        @iut.subscribers.size.should == 2
+      end
+
+      it "should notify all subscribers when requested to do so" do
+        a = TestSubscriber.new
+        b = TestSubscriber.new
+        @iut.subscribe(a)
+        @iut.subscribe(b)
+        a.data.nil?.should == true
+        b.data.nil?.should == true
+        @iut.notify_subscribers("somedata")
+        a.data.should == "somedata"
+        b.data.should == "somedata"
+      end
+    end
+  end
+end

data/spec/converse/comms/html/html_conversation_spec.rb

@@ -0,0 +1,197 @@
+require "spec_helper"
+require "comms/html/html_conversation"
+
+module Converse
+  describe HTMLConversation do
+    class TestSubscriber
+      attr_accessor :data
+
+      def notify(message)
+        @data = message
+      end
+    end
+
+    class TestRequest
+      attr_accessor :body
+      attr_accessor :account
+      attr_accessor :password
+
+      def initialize
+        @body = "body"
+        basic_auth("account", "password")
+      end
+
+      def basic_auth(account, password)
+        @account = account
+        @password = password
+      end
+    end
+
+    class TestResponse
+      attr_accessor :body
+
+      def initialize
+        @body = "response body"
+      end
+    end
+
+    before :each do
+      @mock_connection = []
+      @iut = HTMLConversation.new("http://somewhere.com:9876")
+      @iut.username = "user"
+      @iut.password = "password"
+      @iut.use_ssl = false
+      @subscriber = TestSubscriber.new
+    end
+
+    context "on construction" do
+      it "should remember username, password, SSL should be forced to false" do
+        @iut.username.should == "user"
+        @iut.password.should == "password"
+        @iut.use_ssl.should == false
+      end
+
+      it "should configure port to 80 if not provided" do
+        @iut = HTMLConversation.new("http://somewhere.com")
+        @iut.port.should == 80
+      end
+    end
+
+    context "when configured" do
+      it "should remember username, password, port and ssl" do
+        @iut.username = "user2"
+        @iut.password = "password2"
+        @iut.use_ssl = true
+        @iut.port = 443
+        @iut.username.should == "user2"
+        @iut.password.should == "password2"
+        @iut.use_ssl.should == true
+        @iut.port.should == 443
+      end
+    end
+
+    context "when processing message notification" do
+      it "should notify subscribers of requests when asked to" do
+        @iut.subscribe(@subscriber)
+        @iut.request = TestRequest.new
+        @iut.populate_request("http://somewhere.com/something", "request data")
+        @subscriber.should_receive(:notify).with("HTTP=>\nrequest\nrequest data\n")
+        @iut.notify_subscribers_of_request("request")
+      end
+
+      it "should notify subscribers of responses" do
+        @iut.subscribe(@subscriber)
+        @iut.response = TestRequest.new
+        @subscriber.should_receive(:notify).with("<=HTTP\nbody\n")
+        @iut.notify_subscribers_of_response
+      end
+    end
+
+    context "when asked to populate request data" do
+      it "should set the request body to the data if there is data" do
+        @iut.request = TestRequest.new
+        @iut.populate_request("http://somewhere.com/something", "request data")
+        @iut.request.body.should == "request data"
+      end
+
+      it "should not change the request body if no data is provided" do
+        @iut.request = TestRequest.new
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.body.should == "body"
+
+        @iut.request.body = nil
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.body.nil?.should == true
+      end
+
+      it "should fill in authentication information if available" do
+        @iut.request = TestRequest.new
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.account.should == "user"
+        @iut.request.password.should == "password"
+
+        @iut.username = nil
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.account.nil?.should == true
+        @iut.request.password.should == "password"
+
+        @iut.username = "user"
+        @iut.password = nil
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.account.should == "user"
+        @iut.request.password.nil?.should == true
+
+        @iut.username = nil
+        @iut.request.account = nil
+        @iut.request.password = nil
+        @iut.populate_request("http://somewhere.com/something", nil)
+        @iut.request.account.nil?.should == true
+        @iut.request.password.nil?.should == true
+      end
+
+      it "should notify subscribers of the request update" do
+        @iut.subscribe(@subscriber)
+        @iut.request = TestRequest.new
+        @subscriber.should_receive(:notify).with("HTTP=>\nhttp://somewhere.com/something\nbody\n")
+        @iut.populate_request("http://somewhere.com/something", nil)
+      end
+    end
+
+    context "when asked to connect" do
+      it "should call Net::HTTP.start without SSL parameters if SSL is not configured" do
+        @iut.use_ssl = false
+        Net::HTTP.should_receive(:start) do |host, port|
+          host.should == "somewhere.com"
+          port.should == 9876
+        end
+        @iut.connect
+      end
+
+      it "should call Net::HTTP.start with SSL parameters if SSL is configured" do
+        @iut.use_ssl = true
+        Net::HTTP.should_receive(:start) do |host, port, ssl|
+          host.should == "somewhere.com"
+          port.should == 9876
+          ssl.should == {:use_ssl=>"yes"}
+        end
+        @iut.connect
+      end
+    end
+
+    context "when conversing" do
+      it "should populate the request with the data provided, connect and issue the request, then notify subscribers with and return the response" do
+        prepare_converse
+        test_response
+      end
+
+      it "should create a Net:HTTP:Get request and converse when asking" do
+        prepare_converse
+        Net::HTTP::Get.should_receive(:new).with("http://newpath/go").and_return(@iut.request)
+        @iut.ask "http://newpath/go", "some data"
+      end
+
+      it "should create a Net:HTTP:Post request and converse when saying" do
+        prepare_converse
+        Net::HTTP::Post.should_receive(:new).with("http://newpath/go").and_return(@iut.request)
+        @iut.say"http://newpath/go", "some data"
+      end
+
+      def prepare_converse
+        @iut.request = TestRequest.new
+        @iut.subscribe(@subscriber)
+        Net::HTTP.should_receive(:start).and_return(@mock_connection)
+        @test_response = TestResponse.new
+        @mock_connection.should_receive(:request).with(@iut.request).and_return(@test_response)
+        @subscriber.should_receive(:notify).with("HTTP=>\nhttp://newpath/go\nsome data\n")
+        @subscriber.should_receive(:notify).with("<=HTTP\nresponse body\n")
+      end
+
+      def test_response
+        result = @iut.converse("http://newpath/go", "some data")
+        @iut.request.body.should == "some data"
+        result.should == @test_response
+      end
+    end
+  end
+end
+

data/spec/converse/comms/mysql/mysql_conversation_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "comms/mysql/mysql_conversation"
+
+module Converse
+  describe MysqlConversation do
+    before :each do
+      @iut = MysqlConversation.new("mysql://user:pass@somewhere.com:7743/databasename")
+      @client = "client"
+    end
+
+    context "on construction" do
+      it "should parse the URI provided and extract the username, password and database" do
+        setup_connection
+        @iut.connect
+      end
+    end
+
+    context "when asked to connect to the database" do
+      it "should create a mysql client and attempt to connect" do
+        setup_connection
+        @iut.connect
+      end
+    end
+
+    context "when asked to converse given a query" do
+      it "should connect to the database and issue the query on converse" do
+        setup_query
+        @iut.converse
+      end
+
+      it "should connect to the database and issue the query on ask" do
+        setup_query
+        @iut.ask
+      end
+
+      it "should connect to the database and issue the query on say" do
+        setup_query
+        @iut.say
+      end
+    end
+
+    def setup_query
+      @iut.query = "SHOW DATABASES"
+      setup_connection
+      @client.should_receive(:query).with("SHOW DATABASES")
+    end
+
+    def setup_connection
+      Mysql2::Client.should_receive(:new).with({:host => "somewhere.com",
+                                                :port => 7743,
+                                                :username => "user",
+                                                :password => "pass",
+                                                :database => "databasename"}).and_return(@client)
+    end
+  end
+end

data/spec/converse/comms/simple_logger_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+require 'rspec/mocks/standalone'
+
+module Converse
+  describe SimpleLogger do
+    before :each do
+      @iut = SimpleLogger.new
+    end
+
+    context "when notified" do
+      it "should output the message to standard output" do
+        @iut.stub!(:puts).with("testing")
+        @iut.notify("testing")
+      end
+    end
+  end
+end

data/spec/converse/interaction_spec.rb

@@ -0,0 +1,257 @@
+require "spec_helper"
+require "interaction"
+
+module Converse
+  describe Interaction do
+    before :each do
+      @iut = Converse::Interaction.new
+      @broker = "test broker"
+      @concern = "test concern"
+      @action = "action"
+      @substance = "substance"
+      @conversation = "conversation"
+    end
+
+    context "on construction" do
+      it "should have all attributes set to nil" do
+        @iut.broker.nil?.should == true
+        @iut.concern.nil?.should == true
+        @iut.action.nil?.should == true
+        @iut.substance.nil?.should == true
+        @iut.conversation.nil?.should == true
+        @iut.should_i_ask.nil?.should == true
+      end
+    end
+
+    context "when asked to discuss a concern with a broker" do
+      it "should remember the broken and concern and return the interaction" do
+        out = @iut.discuss_with_broker_concerning(@broker, @concern)
+        @iut.broker.should == @broker
+        @iut.concern.should == @concern
+        out.should == @iut
+      end
+    end
+
+    context "when configured to ask a broker about a concern" do
+      it "should remember the broker and concern, and the fact that it should ask, and return the interaction" do
+        out = @iut.ask_broker_concerning(@broker, @concern)
+        @iut.broker.should == @broker
+        @iut.concern.should == @concern
+        @iut.should_i_ask.should == true
+        out.should == @iut
+      end
+    end
+
+    context "when configured to tell a broker about a concern" do
+      it "should remember the broker and concern, and the fact that it should tell, and return the interaction" do
+        out = @iut.tell_broker_concerning(@broker, @concern)
+        @iut.broker.should == @broker
+        @iut.concern.should == @concern
+        @iut.should_i_ask.should == false
+        out.should == @iut
+      end
+    end
+
+    context "when configured to ask a broker" do
+      it "should remember the broker and the fact that it should ask and return the interaction (ask_broker)" do
+        out = @iut.ask_broker(@broker)
+        @iut.broker.should == @broker
+        @iut.should_i_ask.should == true
+        out.should == @iut
+      end
+
+      it "should remember the fact that it should ask and return the interaction (by_asking)" do
+        out = @iut.by_asking
+        @iut.should_i_ask.should == true
+        out.should == @iut
+      end
+    end
+
+    context "when configured to tell a broker" do
+      it "should remember the broker and the fact that it should tell and return the interaction (tell_broker)" do
+        out = @iut.tell_broker(@broker)
+        @iut.broker.should == @broker
+        @iut.should_i_ask.should == false
+        out.should == @iut
+      end
+
+      it "should remember the fact that it should tell and return the interaction (by_saying)" do
+        out = @iut.by_saying
+        @iut.should_i_ask.should == false
+        out.should == @iut
+      end
+    end
+
+    context "when asked to discuss with a broker" do
+      it "should remember the broker and return the interaction" do
+        out = @iut.discuss_with(@broker)
+        @iut.broker.should == @broker
+        out.should == @iut
+      end
+    end
+
+    context "when raising a concern" do
+      it "should remember the concern and return the interaction" do
+        out = @iut.concerning(@concern)
+        @iut.concern.should == @concern
+        out.should == @iut
+      end
+    end
+
+    context "when indicating an action" do
+      it "should remember the action and return the interaction (about)" do
+        out = @iut.about(@action)
+        @iut.action.should == @action
+        out.should == @iut
+      end
+
+      it "should remember the action and return the interaction (to)" do
+        out = @iut.to(@action)
+        @iut.action.should == @action
+        out.should == @iut
+      end
+    end
+
+    context "when provided with substance" do
+      it "should remember the substance and return the interaction (detailed_by)" do
+        out = @iut.detailed_by(@substance)
+        @iut.substance.should == @substance
+        out.should == @iut
+      end
+
+      it "should remember the substance and return the interaction (using)" do
+        out = @iut.using(@substance)
+        @iut.substance.should == @substance
+        out.should == @iut
+      end
+
+      it "should remember the substance and return the interaction (with)" do
+        out = @iut.with(@substance)
+        @iut.substance.should == @substance
+        out.should == @iut
+      end
+    end
+
+    context "when engaging in conversation" do
+      it "should ask the conversation to say when saying" do
+        @iut.conversation = @conversation
+        @conversation.should_receive(:say)
+        @iut.say
+      end
+
+      it "should ask the conversation to ask when asking" do
+        @iut.conversation = @conversation
+        @conversation.should_receive(:ask)
+        @iut.ask
+      end
+
+      it "should subscribe a simple logger to the conversation" do
+        @iut.discuss_with(@broker)
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:say)
+        @broker.should_receive(:open_topic)
+        @broker.should_receive(:broker_conversation).and_return(@conversation)
+        @broker.should_receive(:translate_response)
+        @iut.discuss
+      end
+
+      it "should ask the broker to open the topic with the concern and action and construct a conversation" do
+        @iut.discuss_with(@broker).concerning(@concern).about(@action)
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:say)
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @broker.should_receive(:translate_response)
+        @iut.discuss
+      end
+
+      it "should ask the broker to translate the response received and then interpret the response" do
+        @iut.discuss_with(@broker).concerning(@concern).about(@action)
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:say).and_return("response")
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @broker.should_receive(:translate_response).with("response").and_return("response")
+        @iut.discuss.should == "response"
+      end
+
+      it "should call ask on the conversation when configured to ask" do
+        @iut.discuss_with(@broker).concerning(@concern).about(@action).by_asking
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:ask).and_return("response")
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @broker.should_receive(:translate_response).with("response").and_return("response")
+        @iut.discuss.should == "response"
+      end
+    end
+
+    context "when evaluating responses" do
+      it "should always indicate success" do
+        @iut.success?("anything").should == true
+      end
+    end
+
+    context "when handling error responses" do
+      it "should return the response intact" do
+        @iut.handle_error!("error").should == "error"
+      end
+    end
+
+    context "when handling errors" do
+      it "should call the error handling hook method" do
+        @iut.stub(:success?).and_return(false)
+        @iut.stub(:handle_error!).and_return "called"
+
+        @iut.discuss_with(@broker).concerning(@concern).about(@action).by_asking
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:ask).and_return("response")
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @broker.should_receive(:translate_response).with("called").and_return("called")
+        @iut.discuss.should == "called"
+      end
+
+      it "should return nil if the response is nil" do
+        @iut.stub(:success?).and_return(false)
+
+        @iut.discuss_with(@broker).concerning(@concern).about(@action).by_asking
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:ask).and_return(nil)
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @iut.discuss.nil?.should == true
+      end
+
+      it "should return the response if the response is not nil" do
+        @iut.stub(:success?).and_return(false)
+
+        @iut.discuss_with(@broker).concerning(@concern).about(@action).by_asking
+        @conversation.should_receive(:subscribe)
+        @conversation.should_receive(:ask).and_return("response")
+        @broker.should_receive(:open_topic) do |concern, action|
+          concern.should == "test concern"
+          action.should == "action"
+        end.and_return "topic"
+        @broker.should_receive(:broker_conversation).with("topic").and_return(@conversation)
+        @broker.should_receive(:translate_response).with("response").and_return("response")
+        @iut.discuss.should == "response"
+      end
+    end
+  end
+end

data/spec/converse/rest/rest_broker_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "rest/rest_broker"
+require "comms/html/html_conversation"
+
+module Converse
+  describe RESTBroker do
+    before :each do
+      @iut = RESTBroker.new
+      @iut.host = "somewhere.com"
+      @iut.port = "8080"
+    end
+
+    context "when asked to broker a conversation given a topic" do
+      it "should do broker an HTML conversation on the topic" do
+        conversation = @iut.broker_conversation("topic")
+        conversation.is_a?(HTMLConversation).should == true
+        conversation.uri.should == "topic"
+        conversation.username.nil?.should == true
+        conversation.password.nil?.should == true
+      end
+
+      it "should configure the username if provided" do
+        @iut.username = "user"
+        conversation = @iut.broker_conversation("topic")
+        conversation.is_a?(HTMLConversation).should == true
+        conversation.uri.should == "topic"
+        conversation.username.should == "user"
+        conversation.password.nil?.should == true
+      end
+
+      it "should configure the password if provided" do
+        @iut.password = "password"
+        conversation = @iut.broker_conversation("topic")
+        conversation.is_a?(HTMLConversation).should == true
+        conversation.uri.should == "topic"
+        conversation.username.nil?.should == true
+        conversation.password.should == "password"
+      end
+    end
+
+    context "when asked to open a topic with no concern" do
+      it "should return host_and_port/action" do
+        @iut.open_topic("", "action").should == "http://somewhere.com:8080/action"
+        @iut.open_topic(nil, "action").should == "http://somewhere.com:8080/action"
+      end
+    end
+
+    context "when asked to open a topic with a concern" do
+      it "should return host_and_port/concern/action" do
+        @iut.open_topic("concern", "action").should == "http://somewhere.com:8080/concern/action"
+      end
+    end
+
+    context "when configuring" do
+      it "should return host:port if port is specified" do
+        @iut.host_and_port.should == "somewhere.com:8080"
+      end
+
+      it "should return host only if port is specified" do
+        @iut.port = nil
+        @iut.host_and_port.should == "somewhere.com"
+      end
+
+      it "should remember a host" do
+        @iut.talks_to("somewhereelse.com")
+        @iut.host.should == "somewhereelse.com"
+      end
+
+      it "should remember a port" do
+        @iut.on_port("9090")
+        @iut.port.should == "9090"
+      end
+
+      it "should remember a username" do
+        @iut.authenticated_by("username")
+        @iut.username.should == "username"
+      end
+
+      it "should remember a password" do
+        @iut.with_password("password")
+        @iut.password.should == "password"
+      end
+
+    end
+  end
+end

data/spec/converse/rest/rest_interaction_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+require "rest/rest_interaction"
+
+module Converse
+  describe RESTInteraction do
+    before :each do
+      @iut = RESTInteraction.new
+      @broker = "broker"
+      @action = "action"
+      @substance = "substance"
+    end
+
+    context "when asked to ask a broker about an action with substance" do
+      it "should initialize the broker using an empty concern, the action and substance" do
+        @iut.ask_broker_about(@broker, @action, @substance)
+        @iut.broker.should == @broker
+        @iut.concern.should == ""
+        @iut.action.should == @action
+        @iut.substance.should == @substance
+      end
+    end
+
+    context "when asked to tell a broker about an action with substance" do
+      it "should initialize the broker using an empty concern, the action and substance" do
+        @iut.tell_broker_to(@broker, @action, @substance)
+        @iut.broker.should == @broker
+        @iut.concern.should == ""
+        @iut.action.should == @action
+        @iut.substance.should == @substance
+      end
+    end
+
+    context "when discussing" do
+      class TestConversation
+        attr_accessor :path
+        attr_accessor :data
+
+        def initialize
+          @path =  "somewhere.com/someplace"
+        end
+
+        def ask(data)
+          @data = data
+        end
+
+        def say(path, data)
+          @path = path
+          @data = data
+        end
+      end
+
+      it "should ask the conversation with path and parameters adapted" do
+        @conversation = TestConversation.new
+        @iut.conversation = @conversation
+        @iut.substance = {:param_a => "value_a", :param_b => "value_b"}
+        @iut.ask
+        #cannot guarantee hash ordering, so check for includes
+        @conversation.data.include?("somewhere.com/someplace?").should == true
+        @conversation.data.include?("param_a=value_a").should == true
+        @conversation.data.include?("param_b=value_b").should == true
+        @conversation.data.include?("&").should == true
+      end
+
+      it "should say to the conversation with path and parameters adapted" do
+        @conversation = TestConversation.new
+        @iut.conversation = @conversation
+        @iut.substance = {:param_a => "value_a", :param_b => "value_b"}
+        @conversation.should_receive(:say) do |path, params|
+          path.should == "somewhere.com/someplace"
+          #cannot guarantee hash ordering, so check for includes
+          params.include?("param_a=value_a").should == true
+          params.include?("param_b=value_b").should == true
+          params.include?("&").should == true
+        end
+        @iut.say
+      end
+
+    end
+
+    context "when preparing for RESTful communication" do
+      it "should compile a list of CGI compatible parameters and present it in a string output ready for HTTP communication" do
+        result = @iut.compile_params({:param_a => "value_a", :param_b => "value_b"})
+        #cannot guarantee hash ordering, so check for includes
+        result.include?("param_a=value_a").should == true
+        result.include?("param_b=value_b").should == true
+        result.include?("&").should == true      end
+
+      it "should compile a path and parameter string ready for HTTP communication" do
+        result = @iut.path_with_params("somewhere.com/someplace", {:param_a => "value_a", :param_b => "value_b"})
+        result.include?("somewhere.com/someplace?").should == true
+        result.include?("param_a=value_a").should == true
+        result.include?("param_b=value_b").should == true
+        result.include?("&").should == true
+      end
+
+      it "should output the path if the list of parameters is empty" do
+        result = @iut.path_with_params("somewhere.com/someplace", {})
+        result.should == "somewhere.com/someplace"
+      end
+
+      it "should output the path if the list of parameters is nil" do
+        result = @iut.path_with_params("somewhere.com/someplace", nil)
+        result.should == "somewhere.com/someplace"
+      end
+    end
+
+    context "when receiving a response" do
+      class TestResponse
+        attr_accessor :code
+        attr_accessor :body
+      end
+      it "should return true if the response code is 200" do
+        response = TestResponse.new
+        response.code = "200"
+        @iut.success?(response).should == true
+      end
+
+      it "should return false if the response code is 200" do
+        response = TestResponse.new
+        response.code = "404"
+        @iut.success?(response).should == false
+      end
+
+      it "should transform the response by transparently returning the response" do
+        @iut.format_response("dontchangeme").should == "dontchangeme"
+      end
+
+      it "should interpret the response by transparently returning the response" do
+        response = TestResponse.new
+        response.body = "dontchangeme"
+        @iut.interpret_conversation(response).should == "dontchangeme"
+      end
+
+      it "should format an error response as an array with code and error body" do
+        response = TestResponse.new
+        response.code = "404"
+        response.body = "this is an error"
+        @iut.format_error(response).should == ["404", "this is an error"]
+      end
+    end
+
+    context "as a validator" do
+      it "should not raise an error if validation is in JSON format" do
+        @iut.ensure_that({:param_a => "value_a", :param_b => "value_b"}.to_json)
+        @iut.is_json.should
+      end
+
+      it "should raise an error if validation is not in JSON format" do
+        @iut.ensure_that("nope")
+        expect{ @iut.is_json }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'converse'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..")
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib", "converse")
+
+RSpec.configure do |config|
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: converse
 version: !ruby/object:Gem::Version 
-  hash: 37
+  hash: 35
   prerelease: 
   segments: 
   - 1
   - 0
-  - 25
-  version: 1.0.25
+  - 26
+  version: 1.0.26
 platform: ruby
 authors: 
 - Ernst van Graan
@@ -15,9 +15,50 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-31 00:00:00 Z
-dependencies: []
-
+date: 2012-12-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: Converse provides Broker/Translator classes to facilitate communication across an API by means of conversations
 email: 
 - ernst.van.graan@hetzner.co.za
@@ -51,6 +92,16 @@ files:
 - lib/converse/rest/rest_broker.rb
 - lib/converse/rest/rest_interaction.rb
 - lib/converse/version.rb
+- spec/converse/api_spec.rb
+- spec/converse/broker_spec.rb
+- spec/converse/comms/conversation_spec.rb
+- spec/converse/comms/html/html_conversation_spec.rb
+- spec/converse/comms/mysql/mysql_conversation_spec.rb
+- spec/converse/comms/simple_logger_spec.rb
+- spec/converse/interaction_spec.rb
+- spec/converse/rest/rest_broker_spec.rb
+- spec/converse/rest/rest_interaction_spec.rb
+- spec/spec_helper.rb
 homepage: ""
 licenses: []
 
@@ -84,5 +135,14 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Converse provides Broker/Translator classes to facilitate communication across an API by means of conversations
-test_files: []
-
+test_files: 
+- spec/converse/api_spec.rb
+- spec/converse/broker_spec.rb
+- spec/converse/comms/conversation_spec.rb
+- spec/converse/comms/html/html_conversation_spec.rb
+- spec/converse/comms/mysql/mysql_conversation_spec.rb
+- spec/converse/comms/simple_logger_spec.rb
+- spec/converse/interaction_spec.rb
+- spec/converse/rest/rest_broker_spec.rb
+- spec/converse/rest/rest_interaction_spec.rb
+- spec/spec_helper.rb