scamp 1.2.0 → 2.0.0.pre

data/spec/lib/scamp_spec.rb

@@ -1,33 +1,18 @@
 require "spec_helper"
 
 describe Scamp do
-  before do
-    @valid_params = {:api_key => "6124d98749365e3db2c9e5b27ca04db6", :subdomain => "oxygen"} 
-    @valid_user_cache_data = {123 => {"name" => "foo"}, 456 => {"name" => "bar"}, 'me' => {"name" => "bot", "id" => 123}}
-    
-    # Stub fetch for room data
-    @valid_room_cache_data = {
-      123 => {
-        "id" => 123,
-        "name" => "foo",
-        "users" => []
-      },
-      456 => {
-        "id" => 456,
-        "name" => "bar",
-        "users" => []
-      }
-    }
-  end
-  
   describe "#initialize" do
     it "should work with valid params" do
-      a(Scamp).should be_a(Scamp)
+      Scamp.new do |scamp|
+        scamp.should be_a(Scamp)
+      end
     end
+
     it "should warn if given an option it doesn't know" do
       mock_logger
 
-      a(Scamp, :fred => "estaire").should be_a(Scamp)
+      Scamp.new :fred => "estaire" do |scamp|
+      end
 
       logger_output.should =~ /WARN.*Scamp initialized with :fred => "estaire" but NO UNDERSTAND!/
     end
@@ -35,716 +20,191 @@ describe Scamp do
 
   describe "#verbose" do
     it "should default to false" do
-      a(Scamp).verbose.should be_false
+      Scamp.new do |scamp|
+        scamp.verbose.should be_false
+      end
     end
+
     it "should be overridable at initialization" do
-      a(Scamp, :verbose => true).verbose.should be_true
+      Scamp.new :verbose => true do |scamp|
+        scamp.verbose.should be_true
+      end
     end
   end
 
   describe "#logger" do
     context "default logger" do
-      before { @bot = a Scamp }
-      it { @bot.logger.should be_a(Logger) }
-      it { @bot.logger.level.should be == Logger::INFO }
+      before do
+        Scamp.new do |scamp|
+          @bot = scamp
+        end
+      end
+
+      it "has a log level of INFO" do
+        @bot.logger.should be_a(Logger)
+        @bot.logger.level.should be == Logger::INFO
+      end
     end
+
     context "default logger in verbose mode" do
-      before { @bot = a Scamp, :verbose => true }
-      it { @bot.logger.level.should be == Logger::DEBUG }
+      before do
+       Scamp.new :verbose => true do |scamp|
+         @bot = scamp
+       end
+      end
+
+      it "has a log level of DEBUG" do
+        @bot.logger.level.should be == Logger::DEBUG
+      end
     end
+
     context "overriding default" do
       before do
         @custom_logger = Logger.new("/dev/null")
-        @bot = a Scamp, :logger => @custom_logger
+        Scamp.new :logger => @custom_logger do |scamp|
+          @bot = scamp
+        end
+      end
+
+      it "uses the custom logger provided" do
+        @bot.logger.should be == @custom_logger
       end
-      it { @bot.logger.should be == @custom_logger }
     end
   end
 
   describe "#first_match_only" do
     it "should default to false" do
-      a(Scamp).first_match_only.should be_false
+      Scamp.new do |scamp|
+        scamp.first_match_only.should be_false
+      end
     end
     it "should be settable" do
-      a(Scamp, :first_match_only => true).first_match_only.should be_true
-    end
-  end
-
-  describe "private methods" do
-
-    describe "#process_message" do
-      before do
-        @bot = a Scamp
-        $attempts = 0 # Yes, I hate it too. Works though.
-        @message = {:body => "my message here"}
-
-        @bot.behaviour do
-          2.times { match(/.*/) { $attempts += 1 } }
-        end
-      end
-      after { $attempts = nil }
-      context "with first_match_only not set" do
-        before { @bot.first_match_only.should be_false }
-        it "should process all matchers which attempt the message" do
-          @bot.send(:process_message, @message)
-          $attempts.should be == 2
-        end
-      end
-      context "with first_match_only set" do
-        before do
-          @bot.first_match_only = true
-          @bot.first_match_only.should be_true
-        end
-        it "should only process the first matcher which attempts the message" do
-          @bot.send(:process_message, @message)
-          $attempts.should be == 1
-        end
+      Scamp.new :first_match_only => true do |scamp|
+        scamp.first_match_only.should be_true
       end
     end
   end
-  
-  describe "matching" do
-    
-    context "with conditions" do
-      context "for room" do
-
-        it "should limit matches by id" do
-          canary = mock
-          canary.expects(:lives).once
-          canary.expects(:bang).never
-          
-          bot = a Scamp
-          bot.behaviour do
-            match("a string", :conditions => {:room => 123}) {canary.lives}
-            match("a string", :conditions => {:room => 456}) {canary.bang}
-          end
-          
-          bot.send(:process_message, {:room_id => 123, :body => "a string"})
-        end
 
-        it "should limit matches by array of IDs" do
-          canary = mock
-          canary.expects(:lives).once
-          canary.expects(:bang).never
-          
-          bot = a Scamp
-          bot.behaviour do
-            match("a string", :conditions => {:room => [123]}) {canary.lives}
-            match("a string", :conditions => {:room => [456]}) {canary.bang}
-          end
-          
-          bot.room_cache = @valid_room_cache_data
-
-          bot.send(:process_message, {:room_id => 123, :body => "a string"})
-        end
-
-        it "should limit matches by array in complex form" do
-          canary = mock
-          canary.expects(:lives).once
-          canary.expects(:bang).never
-
-          bot = a Scamp
-          bot.behaviour do
-           match("a string", :conditions => {:rooms => ["foo", 777]}) {canary.lives}
-           match("a string", :conditions => {:room => ["bar"]}) {canary.bang}
-          end
-
-          bot.room_cache = @valid_room_cache_data
-          bot.send(:process_message, {:room_id => 123, :body => "a string"})
-        end
-
-        it "should limit matches by name" do
-          canary = mock
-          canary.expects(:lives).once
-          canary.expects(:bang).never
-          
-          bot = a Scamp
-          bot.behaviour do
-            match("a string", :conditions => {:room => "foo"}) {canary.lives}
-            match("a string", :conditions => {:room => "bar"}) {canary.bang}
-          end
-          
-          bot.room_cache = @valid_room_cache_data
-          
-          bot.send(:process_message, {:room_id => 123, :body => "a string"})
-        end
-
-      end
-      
-      it "should limit matches by user id" do
-        canary = mock
-        canary.expects(:lives).once
-        canary.expects(:bang).never
-        
-        bot = a Scamp
-        bot.behaviour do
-          match("a string", :conditions => {:user => 123}) {canary.lives}
-          match("a string", :conditions => {:user => 456}) {canary.bang}
-        end
-        
-        bot.send(:process_message, {:user_id => 123, :body => "a string"})
-      end
-      
-      it "should limit matches by user name" do
-        canary = mock
-        canary.expects(:lives).once
-        canary.expects(:bang).never
-        
-        bot = a Scamp
-        bot.behaviour do
-          match("a string", :conditions => {:user => "foo"}) {canary.lives}
-          match("a string", :conditions => {:user => "bar"}) {canary.bang}
-        end
-        
-        bot.user_cache = @valid_user_cache_data
-        
-        bot.send(:process_message, {:user_id => 123, :body => "a string"})
-      end
-      
-      it "should limit matches by room and user" do
-        canary = mock
-        canary.expects(:lives).once
-        canary.expects(:bang).never
-        
-        bot = a Scamp
-        bot.behaviour do
-          match("a string", :conditions => {:room => 123, :user => 123}) {canary.lives}
-          match("a string", :conditions => {:room => 456, :user => 456}) {canary.bang}
-        end
-        
-        bot.room_cache = @valid_room_cache_data
-        bot.user_cache = @valid_user_cache_data
-        bot.send(:process_message, {:room_id => 123, :user_id => 123, :body => "a string"})
-        bot.send(:process_message, {:room_id => 123, :user_id => 456, :body => "a string"})
-        bot.send(:process_message, {:room_id => 456, :user_id => 123, :body => "a string"})
-      end
-      
-      it "should ignore itself if so requested" do
-        canary = mock
-        canary.expects(:bang).never
-
-        bot = a Scamp
-        bot.user_cache = @valid_user_cache_data
-        bot.ignore_self = true
-        bot.ignore_self.should be_true
-        bot.behaviour do
-          match("a string") {canary.bang}
-        end
-        
-        bot.send(:process_message, {:user_id => 123, :body => "a string"})
-      end
-    end
-    
+  describe "matching" do
     describe "strings" do
       it "should match an exact string" do
         canary = mock
         canary.expects(:lives).once
         canary.expects(:bang).never
-        
-        bot = a Scamp
-        bot.behaviour do
-          match("a string") {canary.lives}
-          match("another string") {canary.bang}
-          match("a string like no other") {canary.bang}
-        end
-        
-        bot.send(:process_message, {:body => "a string"})
-      end
-      
-      it "should not match without prefix when required_prefix is true" do
-        canary = mock
-        canary.expects(:bang).never
-        
-        bot = a Scamp, :required_prefix => 'Bot: '
-        bot.behaviour do
-          match("a string") {canary.bang}
-        end
-        
-        bot.send(:process_message, {:body => "a string"})
-      end
 
-      it "should match with exact prefix when required_prefix is true" do
-        canary = mock
-        canary.expects(:lives).once
-        
-        bot = a Scamp, :required_prefix => 'Bot: '
-        bot.behaviour do
-          match("a string") {canary.lives}
+        EM.run_block do
+          Scamp.new do |bot|
+            bot.adapter :rspec, RspecAdapter
+
+            bot.match("a string") {|context, message| canary.lives }
+            bot.match("another string") {|context, message| canary.bang }
+            bot.match("a string like no other") {|context, message| canary.bang }
+
+            bot.connect!
+            bot.adapters[:rspec][:adapter].speak! "a string"
+          end
         end
-        
-        bot.send(:process_message, {:body => "Bot: a string"})
       end
     end
-    
+
 
     describe "regexes" do
       it "should match a regex" do
         canary = mock
         canary.expects(:ping).twice
-        
-        bot = a Scamp
-        bot.behaviour do
-          match /foo/ do
-            canary.ping
+        EM.run_block do
+          Scamp.new do |bot|
+            bot.adapter :rspec, RspecAdapter
+
+            bot.match /foo/ do
+              canary.ping
+            end
+
+            bot.connect!
+            bot.adapters[:rspec][:adapter].speak! "something foo other thing"
+            bot.adapters[:rspec][:adapter].speak! "foomaster"
           end
         end
-        
-        bot.send(:process_message, {:body => "something foo other thing"})
-        bot.send(:process_message, {:body => "foomaster"})
       end
-      
-      it "should make named captures vailable as methods" do
+
+      it "should make named captures available on the message" do
         canary = mock
         canary.expects(:one).with("first")
         canary.expects(:two).with("the rest of it")
-        
-        bot = a Scamp
-        bot.behaviour do
-          match /^please match (?<yousaidthis>\w+) and (?<andthis>.+)$/ do
-            canary.one(yousaidthis)
-            canary.two(andthis)
+
+        EM.run_block do
+          Scamp.new do |bot|
+            bot.adapter :rspec, RspecAdapter
+
+            bot.match /^please match (?<yousaidthis>\w+) and (?<andthis>.+)$/ do |channel, msg|
+              canary.one(msg.matches.yousaidthis)
+              canary.two(msg.matches.andthis)
+            end
+
+            bot.connect!
+            bot.adapters[:rspec][:adapter].speak! "please match first and the rest of it"
           end
         end
-        
-        bot.send(:process_message, {:body => "please match first and the rest of it"})
       end
-      
+
       it "should make matches available in an array" do
         canary = mock
         canary.expects(:one).with("first")
         canary.expects(:two).with("the rest of it")
-        
-        bot = a Scamp
-        bot.behaviour do
-          match /^please match (\w+) and (.+)$/ do
-            canary.one(matches[0])
-            canary.two(matches[1])
-          end
-        end
-        
-        bot.send(:process_message, {:body => "please match first and the rest of it"})
-      end
-      
-      it "should not match without prefix when required_prefix is present" do
-        canary = mock
-        canary.expects(:bang).never
-        
-        bot = a Scamp, :required_prefix => /^Bot[\:,\s]+/i
-        bot.behaviour do
-          match(/a string/) {canary.bang}
-        end
-        
-        bot.send(:process_message, {:body => "a string"})
-        bot.send(:process_message, {:body => "some kind of a string"})
-        bot.send(:process_message, {:body => "a string!!!"})
-      end
 
-      it "should match with regex prefix when required_prefix is present" do
-        canary = mock
-        canary.expects(:lives).times(4)
-        
-        bot = a Scamp, :required_prefix => /^Bot\W{1,2}/i
-        bot.behaviour do
-          match(/a string/) {canary.lives}
+        EM.run_block do
+          Scamp.new do |bot|
+            bot.adapter :rspec, RspecAdapter
+
+            bot.match /^please match (\w+) and (.+)$/ do |channel, msg|
+              canary.one(msg.matches[0])
+              canary.two(msg.matches[1])
+            end
+
+            bot.connect!
+            bot.adapters[:rspec][:adapter].speak! "please match first and the rest of it"
+          end
         end
-        
-        bot.send(:process_message, {:body => "Bot, a string"})
-        bot.send(:process_message, {:body => "Bot a string"})
-        bot.send(:process_message, {:body => "bot: a string"})
-        bot.send(:process_message, {:body => "Bot: a string oh my!"})
       end
     end
   end
-  
-  describe "match block" do
-    it "should make the room details available to the action block" do
-      canary = mock
-      canary.expects(:id).with(123)
-      canary.expects(:name).with(@valid_room_cache_data[123]["name"])
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("a string") {
-          canary.id(room_id)
-          canary.name(room)
-        }
-      end
-      
-      bot.room_cache = @valid_room_cache_data
-      bot.send(:process_message, {:room_id => 123, :body => "a string"})
-    end
-    
-    it "should make the speaking user details available to the action block" do
-      canary = mock
-      canary.expects(:id).with(123)
-      canary.expects(:name).with(@valid_user_cache_data[123]["name"])
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("a string") {
-          canary.id(user_id)
-          canary.name(user)
-        }
-      end
-      
-      bot.user_cache = @valid_user_cache_data
-      bot.send(:process_message, {:user_id => 123, :body => "a string"})
-    end
-    
-    it "should make the message said available to the action block" do
-      canary = mock
-      canary.expects(:message).with("Hello world")
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          canary.message(message)
-        }
-      end
-      
-      bot.send(:process_message, {:body => "Hello world"})
-    end
-    
-    it "should provide a command list" do
-      canary = mock
-      canary.expects(:commands).with([["Hello world", {}], ["Hello other world", {:room=>123}], [/match me/, {:user=>123}]])
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          canary.commands(command_list)
-        }
-        match("Hello other world", :conditions => {:room => 123}) {}
-        match(/match me/, :conditions => {:user => 123}) {}
-      end
-      
-      bot.send(:process_message, {:body => "Hello world"})
-    end
-    
-    it "should be able to play a sound to the room the action was triggered in" do
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          play "yeah"
-        }
-      end
-      
-      EM.run_block {
-        room_id = 123
-        stub_request(:post, "https://#{@valid_params[:subdomain]}.campfirenow.com/room/#{room_id}/speak.json").
-          with(
-            :body => "{\"message\":{\"body\":\"yeah\",\"type\":\"SoundMessage\"}}",
-            :headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}
-          )
-            
-        bot.send(:process_message, {:room_id => room_id, :body => "Hello world"})
-      }
-    end
-    
-    it "should be able to play a sound to an arbitrary room" do
-      play_room = 456
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          play "yeah", play_room
-        }
-      end
-      
-      EM.run_block {
-        room_id = 123
-        stub_request(:post, "https://#{@valid_params[:subdomain]}.campfirenow.com/room/#{play_room}/speak.json").
-          with(
-            :body => "{\"message\":{\"body\":\"yeah\",\"type\":\"SoundMessage\"}}",
-            :headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}
-          )
-            
-        bot.send(:process_message, {:room_id => room_id, :body => "Hello world"})
-      }
-    end
-    
-    it "should be able to say a message to the room the action was triggered in" do
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          say "yeah"
-        }
-      end
-      
-      EM.run_block {
-        room_id = 123
-        stub_request(:post, "https://#{@valid_params[:subdomain]}.campfirenow.com/room/#{room_id}/speak.json").
-          with(
-            :body => "{\"message\":{\"body\":\"yeah\",\"type\":\"Textmessage\"}}",
-            :headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}
-          )
-            
-        bot.send(:process_message, {:room_id => room_id, :body => "Hello world"})
-      }
-    end
-    
-    it "should be able to say a message to an arbitrary room" do
-      play_room = 456
-      
-      bot = a Scamp
-      bot.behaviour do
-        match("Hello world") {
-          say "yeah", play_room
-        }
-      end
-      
-      EM.run_block {
-        room_id = 123
-        stub_request(:post, "https://#{@valid_params[:subdomain]}.campfirenow.com/room/#{play_room}/speak.json").
-          with(
-            :body => "{\"message\":{\"body\":\"yeah\",\"type\":\"Textmessage\"}}",
-            :headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}
-          )
-            
-        bot.send(:process_message, {:room_id => room_id, :body => "Hello world"})
-      }
-    end
-  end
 
-  describe "API" do
-    context "user operations" do
-      it "should fetch user data" do
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:get, "https://#{@valid_params[:subdomain]}.campfirenow.com/users/123.json").
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-            to_return(:status => 200, :body => Yajl::Encoder.encode(:user => @valid_user_cache_data[123]), :headers => {})
-          bot.username_for(123)
-        }
-      end
-      
-      it "should handle HTTP errors fetching user data" do
-        mock_logger
-        bot = a Scamp
-
-        url = "https://#{@valid_params[:subdomain]}.campfirenow.com/users/123.json"
-        EM.run_block {
-          stub_request(:get, url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-            to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-          lambda {bot.username_for(123)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't fetch user data for user 123 with url #{url}, http response from API was 502/
-      end
-      
-      it "should handle network errors fetching user data" do
-        mock_logger
-        bot = a Scamp
-        
-        url = "https://#{@valid_params[:subdomain]}.campfirenow.com/users/123.json"
-        EM.run_block {
-          stub_request(:get, url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).to_timeout
-          lambda {bot.username_for(123)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't connect to #{url} to fetch user data for user 123/
+  describe ".adapter" do
+    let(:adapter) { mock }
+    before do
+      RspecAdapter.stubs(:new) do
+        adapter
       end
     end
-    
-    context "room operations" do
-      before do
-        @room_list_url = "https://#{@valid_params[:subdomain]}.campfirenow.com/rooms.json"
-        @me_list_url = "https://#{@valid_params[:subdomain]}.campfirenow.com/users/me.json"
-        @room_url = "https://#{@valid_params[:subdomain]}.campfirenow.com/room/123.json"
-        @stream_url = "https://streaming.campfirenow.com/room/123/live.json"
-      end
-      
-      it "should fetch a room list" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:get, @room_list_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).
-            to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => @valid_room_cache_data.values), :headers => {})
-          bot.send(:populate_room_list)
-        }
-        logger_output.should =~ /DEBUG.*Fetched room list/
-      end
-
-      it "should invoke the post connection callback" do
-        mock_logger
-        bot = a Scamp
-
-        invoked_cb = false
-
-        EM.run_block {
-          stub_request(:get, @room_list_url).
-          with(:headers => {
-                 'Authorization'=>[@valid_params[:api_key], 'X'],
-                 'Content-Type' => 'application/json'
-               }).
-          to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => @valid_room_cache_data.values), :headers => {})
-
-          stub_request(:get, @room_list_url).
-          with(:headers => {
-                 'Authorization'=>[@valid_params[:api_key], 'X']
-               }).
-          to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => @valid_room_cache_data.values), :headers => {})
 
-          # Disable fetch_data_for, not important to this test.
-          Scamp.any_instance.expects(:fetch_data_for).returns(nil)
+    it "subscribes to an adapter" do
+      adapter.expects(:subscribe).once
+      RspecAdapter.stubs(:new).returns adapter
 
-          bot.send(:connect!, [@valid_room_cache_data.keys.first]) do
-            invoked_cb = true
-          end
-        }
-        invoked_cb.should be_true
-      end
-
-      it "should handle HTTP errors fetching the room list" do
-        mock_logger
-        bot = a Scamp
-      
-        EM.run_block {
-          # stub_request(:get, url).
-          #   with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-          #   to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-          stub_request(:get, @room_list_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).
-            to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-          lambda {bot.send(:populate_room_list)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't fetch room list with url #{@room_list_url}, http response from API was 502/
-      end
-      
-      it "should handle network errors fetching the room list" do
-        mock_logger
-        bot = a Scamp
-        EM.run_block {
-          stub_request(:get, @room_list_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).to_timeout
-          lambda {bot.send(:populate_room_list)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't connect to url #{@room_list_url} to fetch room list/
-      end
-      
-      it "should fetch individual room data" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:get, @room_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).
-            to_return(:status => 200, :body => Yajl::Encoder.encode(:room => @valid_room_cache_data[123]), :headers => {})
-          bot.room_name_for(123)
-        }
-        logger_output.should =~ /DEBUG.*Fetched room data for 123/
-      end
-      
-      it "should handle HTTP errors fetching individual room data" do
-        mock_logger
-        bot = a Scamp
-
-        EM.run_block {
-          stub_request(:get, @room_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).
-            to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-          lambda {bot.room_name_for(123)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't fetch room data for room 123 with url #{@room_url}, http response from API was 502/
-      end
-      
-      it "should handle network errors fetching individual room data" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:get, @room_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).to_timeout
-          lambda {bot.room_name_for(123)}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't connect to #{@room_url} to fetch room data for room 123/
-      end
-
-      it "should stream a room"
-
-      it "should handle response errors streaming a room" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:get, @stream_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X']}).
-            to_return(:status => 201, :body => 'foobarbaz', :headers => {})
-            lambda { bot.send(:stream, 123) }.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't parse room data for room 123 with url #{@stream_url}, http response data was foobarbaz.../
+      Scamp.new do |scamp|
+        scamp.adapter :rspec_adapter, RspecAdapter
       end
-
-      it "should handle HTTP errors streaming a room"
     end
-    
-    context "message operations" do
-      before do
-        @message_post_url = "https://#{@valid_params[:subdomain]}.campfirenow.com/room/123/speak.json"
-      end
+  end
 
-      it "should send a message" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:post, @message_post_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).
-            to_return(:status => 201, :body => Yajl::Encoder.encode(:room => @valid_room_cache_data[123]), :headers => {})
-          bot.send(:send_message, 123, "Hi", "Textmessage")
-        }
-        logger_output.should =~ /DEBUG.*Posted message "Hi" to room 123/
+  describe ".plugin" do
+    it "creates a new instance of the plugin" do
+      Scamp::Plugin.expects(:new)
+      Scamp.new do |scamp|
+        scamp.plugin Scamp::Plugin
       end
+    end
 
-      it "should paste a message" do
-        mock_logger
-        bot = a Scamp
-
-        EM.run_block {
-          stub_request(:post, @message_post_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).
-            to_return(:status => 201, :body => Yajl::Encoder.encode(:room => @valid_room_cache_data[123]), :headers => {})
-          bot.send(:send_message, 123, "Hi", "PasteMessage")
-        }
-        logger_output.should =~ /DEBUG.*Posted message "Hi" to room 123/
-      end
+    it "passes options through to plugin instance" do
+      Scamp.new do |scamp|
+        opts = {:hello => "World"}
+        Scamp::Plugin.expects(:new).with(scamp, opts)
 
-      it "should handle HTTP errors fetching individual room data" do
-        mock_logger
-        bot = a Scamp
-
-        EM.run_block {
-          stub_request(:post, @message_post_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).
-            to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-          lambda {bot.send(:send_message, 123, "Hi", "Textmessage")}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't post message "Hi" to room 123 using url #{@message_post_url}, http response from the API was 502/
-      end
-      
-      it "should handle network errors fetching individual room data" do
-        mock_logger
-        bot = a Scamp
-        
-        EM.run_block {
-          stub_request(:post, @message_post_url).
-            with(:headers => {'Authorization'=>[@valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).to_timeout
-          lambda {bot.send(:send_message, 123, "Hi", "Textmessage")}.should_not raise_error
-        }
-        logger_output.should =~ /ERROR.*Couldn't connect to #{@message_post_url} to post message "Hi" to room 123/
+        scamp.plugin Scamp::Plugin, opts
       end
     end
   end
 
-  def a klass, params={}
-    params ||= {}
-    params = @valid_params.merge(params) if klass == Scamp
-    klass.new(params)
-  end
-
   # Urg
   def mock_logger
     @logger_string = StringIO.new