connfu-client 0.1

data/spec/dsl_spec.rb

@@ -0,0 +1,159 @@
+#
+# connFu is a platform of Telefonica delivered by Bluevia Labs
+# Please, check out www.connfu.com and if you need more information
+# contact us at mailto:support@connfu.com
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'examples')
+
+require 'spec_helper'
+
+# Conference application
+require 'conference/conference_app'
+
+describe Connfu::DSL do
+
+  let(:prov_client) {
+    application = Connfu::Provisioning::Application.new(API_KEY, ENDPOINT)
+    application.stub(:name) {APP_NAME}
+    application.stub(:description) {APP_DESCRIPTION}
+    application.stub(:stream_name) {APP_STREAM_NAME}
+
+    obj = double 'prov_client'
+    obj.stub(:get_info) { application }
+    obj.stub(:get_channels) {[]}
+    obj
+  }
+
+  before(:each) do
+
+    Connfu.stub(:prov_client).and_return(prov_client)
+    Connfu.should_receive(:prov_client).twice
+
+    Connfu::Listener.any_instance.stub(:start) { true }
+    Connfu::Listener.any_instance.stub(:join) { true }
+    Connfu::Dispatcher.any_instance.stub(:join) { true }
+    Connfu::ConnfuStream.any_instance.stub(:start_listening) { nil }
+    Connfu::Provisioning::Application.any_instance.stub(:get_channels).and_return {[]}
+
+    @connfu = Connfu.application(API_KEY) {
+
+      listen(:voice) do |channel|
+        channel.on(:new) do |call|
+          puts "#{NEW_CALL_MESSAGE} on number #{call[:destination]}"
+          conf = ConferenceApp::find_by_conference_number(call[:destination])
+          if conf.is_allowed?(call[:origin])
+            puts "whitelist number received"
+          else
+            puts "not whitelist number"
+          end
+        end
+
+        channel.on(:leave) do |call|
+          puts "#{call[:origin]} #{HANG_MESSAGE} #{call[:destination]}"
+          ConferenceApp::find(call[:destination]).end(call[:origin])
+        end
+
+        channel.on(:foo) do
+        end
+      end
+
+      listen(:twitter) do |channel|
+
+        channel.filter = "text has #conference"
+
+        channel.on(:new) do |tweet|
+          puts "A new tweet arrived"
+          conf = ConferenceApp::find_by_twitter_user(tweet[:origin])
+          conf.wall.print("#{tweet[:origin]}: has tweeted #{tweet[:destination]}")
+        end
+
+      end
+
+      listen(:foo) do |channel|
+        channel.on(:new) do |message|
+          puts "This is an unsupported channel"
+        end
+      end
+
+    }
+
+  end
+
+  context "channels" do
+
+    it "should have two channels defined" do
+      @connfu.listener_channels.length.should eql(2)
+    end
+
+    it "should have the channels :voice and :twitter" do
+      [:voice, :twitter].each { |channel|
+        @connfu.listener_channels.keys.should include(channel)
+      }
+    end
+
+    it "channel voice blocks length should be 4 (one per event :new, :join, :leave, :new_topic)" do
+      @connfu.listener_channels[:voice].blocks.length.should eql(4)
+    end
+
+    it "channel voice should have one block defined in :new event" do
+      @connfu.listener_channels[:voice].blocks[:new].length.should eql(1)
+      @connfu.listener_channels[:voice].blocks[:leave].length.should eql(1)
+    end
+
+    it "channel voice should have one block defined in :hang event" do
+      @connfu.listener_channels[:voice].blocks[:leave].length.should eql(1)
+    end
+
+    it "channel twitter should have one block defined in :new event" do
+      @connfu.listener_channels[:twitter].blocks[:new].length.should eql(1)
+    end
+
+  end
+
+  context "filters" do
+    it "should defined propertly the channel filter" do
+      @connfu.listener_channels[:twitter].filter.should eql("text has #conference")
+    end
+
+  end
+
+  context "messages" do
+
+    context "voice" do
+
+      it "should execute the defined block when a :new event is raised" do
+        @connfu.listener_channels[:voice].should_receive(:puts).with("#{NEW_CALL_MESSAGE} on number 222").once
+        @connfu.listener_channels[:voice].should_receive(:puts).with("whitelist number received").once
+
+        # throw event
+        @connfu.listener_channels[:voice].message(:new, {:origin => "111", :destination => "222"})
+      end
+
+      it "should execute the defined block when a :hang event is raised" do
+        @connfu.listener_channels[:voice].should_receive(:puts).with("111 #{HANG_MESSAGE} 222").once
+        @connfu.listener_channels[:voice].message(:leave, {:origin => "111", :destination => "222"})
+      end
+    end
+
+    context "twitter" do
+      it "should execute the defined block when a :new event is raised" do
+        # mock wall
+        wall = Wall.new
+        wall.should_receive(:puts).with("juandebravo: has tweeted My new tweet").once
+        conference = Conference.new("twitter")
+        conference.should_receive(:wall).and_return(wall)
+
+        # mock conference
+        ConferenceApp.should_receive(:find_by_twitter_user).with("juandebravo").and_return(conference)
+
+        @connfu.listener_channels[:twitter].should_receive(:puts).with("A new tweet arrived").once
+
+        # throw event
+        @connfu.listener_channels[:twitter].message(:new, {:origin => "juandebravo", :destination => "My new tweet"})
+      end
+    end
+
+  end
+
+end

data/spec/listener_channel_spec.rb

@@ -0,0 +1,130 @@
+#
+# connFu is a platform of Telefonica delivered by Bluevia Labs
+# Please, check out www.connfu.com and if you need more information
+# contact us at mailto:support@connfu.com
+#
+
+require 'spec_helper'
+require 'connfu'
+
+describe Connfu::ListenerChannel do
+
+  let(:prov_client) {
+    application = Connfu::Provisioning::Application.new(API_KEY, ENDPOINT)
+    application.stub(:name) {APP_NAME}
+    application.stub(:description) {APP_DESCRIPTION}
+    application.stub(:stream_name) {APP_STREAM_NAME}
+
+    obj = double 'prov_client'
+    obj.stub(:get_info) { application }
+    obj.stub(:get_channels) {[]}
+    obj
+  }
+
+  context "channel types" do
+    it "defines four supported channel types" do
+      Connfu::ListenerChannel::CHANNEL_TYPES.length.should eql(4)
+    end
+  end
+
+  context "listener channels" do
+    before(:each) do
+      Connfu.stub(:prov_client).and_return(prov_client)
+      Connfu.should_receive(:prov_client).twice
+
+      Connfu::Listener.any_instance.stub(:start) { true }
+      Connfu::Listener.any_instance.stub(:join) { true }
+      Connfu::Dispatcher.any_instance.stub(:join) { true }
+      Connfu::Provisioning::Application.any_instance.stub(:get_channels).and_return { [] }
+      Connfu::ConnfuStream.any_instance.stub(:start_listening) { nil }
+    end
+
+
+    it "unsupported channel is unconsidered" do
+
+      connfu = Connfu.application(API_KEY) {
+        listen(:foo) do
+          on(:new) do |call|
+            puts "foo bar"
+          end
+        end
+        listen(:twitter) do
+          on(:new) do |call|
+            puts "foo bar"
+          end
+        end
+      }
+
+      connfu.listener_channels.length.should eql(1)
+    end
+
+    it "supports RSS channel" do
+      connfu = Connfu.application(API_KEY) {
+        listen(:rss) do
+          on(:new) do |rss|
+            puts "foo bar"
+          end
+        end
+      }
+      connfu.listener_channels.length.should eql(1)
+    end
+
+    it "supports sms channel" do
+      connfu = Connfu.application(API_KEY) {
+        listen(:sms) do
+          on(:new) do |sms|
+            puts "foo bar"
+          end
+        end
+      }
+      connfu.listener_channels.length.should eql(1)
+    end
+
+    it "supports twitter channel" do
+      connfu = Connfu.application(API_KEY) {
+        listen(:twitter) do
+          on(:new) do |tweet|
+            puts "foo bar"
+          end
+        end
+      }
+      connfu.listener_channels.length.should eql(1)
+    end
+
+    it "supports voice channel" do
+      connfu = Connfu.application(API_KEY) {
+        listen(:voice) do
+          on(:new) do |call|
+            puts "foo bar"
+          end
+        end
+      }
+      connfu.listener_channels.length.should eql(1)
+    end
+
+
+    it "supports more than one channel" do
+      connfu = Connfu.application(API_KEY) {
+        listen(:voice) do
+          on(:new) do |call|
+            puts "foo bar"
+          end
+        end
+
+        listen(:rss) do
+          on(:new) do |rss|
+            puts "foo bar"
+          end
+        end
+      }
+      connfu.listener_channels.length.should eql(2)
+    end
+
+    it "raise an exception if no channel defined" do
+      lambda { @connfu = Connfu.application(API_KEY) {
+      } }.should raise_error(Exception)
+
+    end
+
+  end
+end

data/spec/listener_spec.rb

@@ -0,0 +1,67 @@
+#
+# connFu is a platform of Telefonica delivered by Bluevia Labs
+# Please, check out www.connfu.com and if you need more information
+# contact us at mailto:support@connfu.com
+#
+
+
+require 'spec_helper'
+
+describe Connfu::Listener do
+
+  let(:prov_client) {
+    application = Connfu::Provisioning::Application.new(API_KEY, ENDPOINT)
+    application.stub(:name) {APP_NAME}
+    application.stub(:description) {APP_DESCRIPTION}
+    application.stub(:stream_name) {APP_STREAM_NAME}
+
+    obj = double 'prov_client'
+    obj.stub(:get_info) { application }
+    obj.stub(:get_channels) {[]}
+    obj
+  }
+
+  before(:each) do
+    Connfu.stub(:prov_client).and_return(prov_client)
+    Connfu.should_receive(:prov_client).twice
+
+    Connfu::Dispatcher.any_instance.stub(:max_messages).and_return(10)
+    Connfu::Listener.any_instance.stub(:max_messages).and_return(10)
+
+    Connfu::ConnfuStream.any_instance.stub(:start_listening) { nil }
+
+    @id = 0
+
+    Connfu::Provisioning::Application.any_instance.stub(:get_channels).and_return {[]}
+
+    Connfu::ConnfuStream.any_instance.stub(:get) {
+      @id+=1
+      message = "{\"id\":\"#{@id}\",\"remoteId\":\"87872349432582144\",\"summary\":\"\",\"content\":\":foo => \\\"bar\\\"\",\"sender\":\"twitter://connfudev/\",\"recipients\":[],\"tags\":[],\"links\":[],\"attachments\":[],\"timeStamp\":\"2011-07-04T13:16:15.000Z\",\"isDeleted\":false,\"isPublic\":true,\"isArticle\":false}"
+      Connfu::ConnfuMessageFormatter.send(:format_message, message) # private method
+    }
+
+    @connfu = Connfu.application(API_KEY) {
+      listen(:twitter) do |channel|
+        channel.filter = "text has #conference"
+
+        channel.on(:new) do |tweet|
+          # puts "A new tweet arrived"
+        end
+      end
+
+    }
+
+  end
+
+  context "twitter stream" do
+    describe "listener" do
+      it "should be an instance of Connfu::Listener when initialized" do
+        @connfu.listener.should be_an_instance_of(Connfu::Listener)
+      end
+      it "should receive ten messages" do
+        @connfu.listener.counter.should eql(10)
+      end
+    end
+  end
+
+end

data/spec/provisioning/application_spec.rb

@@ -0,0 +1,47 @@
+#
+# connFu is a platform of Telefonica delivered by Bluevia Labs
+# Please, check out www.connfu.com and if you need more information
+# contact us at mailto:support@connfu.com
+#
+
+require 'connfu'
+
+require 'spec_helper'
+
+describe Connfu::Provisioning::Application do
+
+  before(:each) do
+    @application = Connfu::Provisioning::Application.new(API_KEY, ENDPOINT)
+  end
+  
+  # Matcher that helps to test if an Application instance is well defined after retrieving data using prov API
+  RSpec::Matchers.define :be_well_defined_as_app do |name, description, stream_name|
+    match do |app| # app should be the Connfu::Provisioning::Application instance
+      app.should be_instance_of(Connfu::Provisioning::Application)
+      app.name.should eql(APP_NAME)
+      app.description.should eql(APP_DESCRIPTION)
+      app.stream_name.should eql(APP_STREAM_NAME)
+    end
+  end
+
+  context "Application" do
+    context "get_info" do
+      it "should retrieve name, description and stream_name" do
+        @application.base.should_receive(:get).once.and_return("{'description':'#{APP_DESCRIPTION}', 'name':'#{APP_NAME}', 'stream_name':'#{APP_STREAM_NAME}'}")
+        app = @application.get_info
+        app.should be_well_defined_as_app(APP_NAME, APP_DESCRIPTION, APP_STREAM_NAME)        
+      end
+    end
+    
+    describe "instance attributes" do
+      # Constructing RSpec examples programmatically
+      {"name" => APP_NAME, "description" => APP_DESCRIPTION, "stream_name" => APP_STREAM_NAME}.each do |attribute, value|
+          it "should make a HTTP request to retrieve app #{attribute}" do
+            @application.base.should_receive(:get).once.and_return("{'description':'#{APP_DESCRIPTION}', 'name':'#{APP_NAME}', 'stream_name':'#{APP_STREAM_NAME}'}")
+            @application.send(attribute.to_sym).should eql(value)
+            @application.should be_well_defined_as_app(APP_NAME, APP_DESCRIPTION, APP_STREAM_NAME)
+          end
+        end
+      end
+    end
+end

data/spec/provisioning/channel_shared_examples.rb

@@ -0,0 +1,52 @@
+
+require 'spec_helper'
+
+def current_time
+  @current_time ||= Time.now
+end
+
+def channel_attrs
+  @channel_attrs ||= {:created_at => "2011-08-26 11:55:10 +0300",
+                       :updated_at => "2011-08-26 11:55:10 +0300"
+                      }
+end
+
+
+shared_examples_for "Channel" do |channel, type|
+
+
+  RSpec::Matchers.define :have_defined_channel_attributes do |expected|
+    match do |channel|
+      channel_attrs.keys.each { |attribute|
+        channel.send(attribute).should eql(expected[attribute])
+      }
+      channel.type.should be_instance_of(String)
+      channel.uid.should be_instance_of(String)
+    end
+  end
+  
+
+  describe "while creating a Channel instance" do
+    it "should initialize properly the meaning attributes" do
+      channel.should be_kind_of(Connfu::Provisioning::Channel)
+      channel.should have_defined_channel_attributes channel_attrs
+    end
+
+  end
+
+  describe "to_hash method" do
+    RSpec::Matchers.define :have_channel_details do |uid|
+      match do |actual|
+        actual.should be_instance_of(Hash)
+        actual.should have_key("uid")
+        actual["uid"].should be_instance_of(String)
+      end
+    end
+
+    it "should retrieve uid" do
+      #channel = Connfu::Provisioning::Channel.new(channel_attrs)
+      channel.to_hash.should have_channel_details(CHANNEL_KEY)
+    end
+  end
+  
+end